@luuthuong/devboard 0.0.0-stage → 1.0.1

package/server-dist/server/board.js

@@ -0,0 +1,486 @@
+// The board pipeline: activity detection → reconcile → column assignment →
+// CardDto. Ports activity_detector.rs, assign_column.rs, card_reconciler.rs and
+// board_state.rs.
+import fs from "node:fs";
+import { displayTitle, newLinkBase } from "./coordination.js";
+import { listWorktrees } from "./git.js";
+import { sessionDisplayTitle } from "./sessions.js";
+import { ksuid } from "./util.js";
+import path from "node:path";
+// ── Activity ─────────────────────────────────────────────────────────────────
+/** Hook events that move a session's state; everything else is ignored. */
+export function activityFromHook(eventName, notificationType) {
+    switch (eventName) {
+        case "UserPromptSubmit":
+            return "activelyWorking";
+        // A (re)opened session sits at its prompt until a UserPromptSubmit says otherwise.
+        case "SessionStart":
+        case "Stop":
+            return "needsAttention";
+        case "Notification":
+            // A permission/elicitation prompt blocks the turn; an idle prompt means it already ended.
+            return notificationType === "idle_prompt" ? "needsAttention" : "idleWaiting";
+        case "SessionEnd":
+            return "ended";
+        default:
+            return null;
+    }
+}
+/** A file write this long after a waiting hook means Claude resumed without a prompt hook. */
+const HOOK_RESUME_MS = 5_000;
+/**
+ * Per-session state: Claude Code hook events when we have them (exact), else
+ * JSONL mtimes compared across polls (changing = working, stable = waiting).
+ */
+export class ActivityTracker {
+    prev = new Map();
+    hooked = new Map();
+    applyHook(sessionId, state, at) {
+        const cur = this.hooked.get(sessionId);
+        if (!cur || at >= cur.at)
+            this.hooked.set(sessionId, { state, at });
+    }
+    detect(jsonlPath, sessionId) {
+        let mtime = 0;
+        try {
+            mtime = fs.statSync(jsonlPath).mtimeMs;
+        }
+        catch {
+            // missing file → epoch → stale
+        }
+        const elapsed = Date.now() - mtime;
+        const prev = this.prev.get(jsonlPath);
+        this.prev.set(jsonlPath, mtime);
+        if (elapsed > 86_400_000)
+            return "stale";
+        if (elapsed > 5 * 60_000)
+            return "ended";
+        const hook = sessionId ? this.hooked.get(sessionId) : undefined;
+        if (hook) {
+            // Working on the hook's word, unless the transcript went quiet (crash: no Stop ever came).
+            if (hook.state === "activelyWorking")
+                return "activelyWorking";
+            if (hook.state !== "ended" && mtime - hook.at > HOOK_RESUME_MS)
+                return "activelyWorking";
+            return hook.state;
+        }
+        if (prev !== undefined)
+            return mtime !== prev ? "activelyWorking" : "needsAttention";
+        return elapsed < 10_000 ? "activelyWorking" : "needsAttention";
+    }
+}
+// ── Column assignment ────────────────────────────────────────────────────────
+export function assignColumn(link, activity, hasWorktree) {
+    const hasPr = link.prLinks.length > 0;
+    const allPrsDone = hasPr && link.prLinks.every((p) => p.status === "MERGED" || p.status === "CLOSED");
+    if (link.manuallyArchived)
+        return "all_sessions";
+    if (activity === "activelyWorking")
+        return "in_progress";
+    if (allPrsDone)
+        return "done";
+    if (link.manualOverrides.column)
+        return link.column;
+    if (hasPr && activity && ["needsAttention", "idleWaiting", "ended", "stale"].includes(activity)) {
+        return "in_review";
+    }
+    switch (activity) {
+        case "needsAttention":
+        case "idleWaiting":
+            return "in_progress";
+        case "ended":
+            if (hasWorktree)
+                return "in_progress";
+            break;
+        default:
+            break;
+    }
+    if (link.source === "github_issue" && !link.sessionLink)
+        return "backlog";
+    if (link.source === "manual" && !link.sessionLink)
+        return "backlog";
+    if (hasWorktree)
+        return "in_progress";
+    if (link.lastActivity) {
+        const hours = (Date.now() - Date.parse(link.lastActivity)) / 3_600_000;
+        if (hours < 24)
+            return "in_progress";
+    }
+    return "all_sessions";
+}
+export function updateCardColumn(link, activity, hasWorktree) {
+    const col = assignColumn(link, activity, hasWorktree);
+    if (col !== link.column) {
+        link.column = col;
+        link.updatedAt = new Date().toISOString();
+    }
+}
+// ── Reconcile ────────────────────────────────────────────────────────────────
+const stripRefsHeads = (b) => (b.startsWith("refs/heads/") ? b.slice("refs/heads/".length) : b);
+const isTrunk = (b) => b === "main" || b === "master";
+function projectMatches(session, link) {
+    if (!session.projectPath || !link.projectPath)
+        return true;
+    return session.projectPath === link.projectPath || session.projectPath.startsWith(`${link.projectPath}/`);
+}
+function findCardForSession(session, cardIdBySessionId, cardsByBranch, linksById) {
+    const exact = cardIdBySessionId.get(session.id);
+    if (exact)
+        return exact;
+    if (session.gitBranch) {
+        const base = stripRefsHeads(session.gitBranch);
+        if (!isTrunk(base)) {
+            const ids = cardsByBranch.get(base);
+            if (ids) {
+                const sameProject = ids.filter((id) => {
+                    const l = linksById.get(id);
+                    return l ? projectMatches(session, l) : false;
+                });
+                const pending = sameProject.find((id) => !linksById.get(id)?.sessionLink);
+                return pending ?? sameProject[0];
+            }
+        }
+    }
+    return adoptByPrompt(session, linksById);
+}
+const normPrompt = (s) => s.replace(/\s+/g, " ").trim();
+/**
+ * A card launched fresh has no session id yet (Claude picks one) and often sits
+ * on a trunk branch, so neither id nor branch matches. Claim the session for the
+ * not-yet-linked card whose prompt it was started with, instead of spawning a
+ * duplicate "discovered" card.
+ */
+function adoptByPrompt(session, linksById) {
+    const first = session.firstPrompt ? normPrompt(session.firstPrompt) : "";
+    if (!first)
+        return undefined;
+    for (const link of linksById.values()) {
+        if (link.sessionLink || link.source === "discovered" || !link.promptBody)
+            continue;
+        if (!projectMatches(session, link))
+            continue;
+        const body = normPrompt(link.promptBody);
+        // firstPrompt is truncated, so accept a prefix match in either direction.
+        if (body && (body.startsWith(first) || first.startsWith(body)))
+            return link.id;
+    }
+    return undefined;
+}
+function newDiscoveredLink(session) {
+    const now = new Date().toISOString();
+    const link = newLinkBase();
+    link.id = ksuid("card");
+    link.name = session.name;
+    link.projectPath = session.projectPath;
+    link.column = "all_sessions";
+    link.createdAt = session.modifiedTime;
+    link.updatedAt = now;
+    link.lastActivity = session.modifiedTime;
+    link.source = "discovered";
+    link.promptBody = session.firstPrompt;
+    link.sessionLink = { sessionId: session.id, sessionPath: session.jsonlPath };
+    if (session.gitBranch) {
+        const base = stripRefsHeads(session.gitBranch);
+        if (!isTrunk(base))
+            link.worktreeLink = { path: "", branch: base };
+    }
+    return link;
+}
+/** Match discovered sessions to existing cards; create cards for new ones. */
+export function reconcile(existing, sessions) {
+    const linksById = new Map(existing.map((l) => [l.id, l]));
+    const cardIdBySessionId = new Map();
+    const cardsByBranch = new Map();
+    const addBranch = (branch, id, dedupe) => {
+        const ids = cardsByBranch.get(branch) ?? [];
+        if (!dedupe || !ids.includes(id))
+            ids.push(id);
+        cardsByBranch.set(branch, ids);
+    };
+    for (const link of linksById.values()) {
+        if (link.sessionLink)
+            cardIdBySessionId.set(link.sessionLink.sessionId, link.id);
+        if (link.worktreeLink?.branch)
+            addBranch(link.worktreeLink.branch, link.id, false);
+        for (const b of link.discoveredBranches ?? [])
+            addBranch(b, link.id, true);
+    }
+    // A. match each session to a card, or create one
+    for (const session of sessions) {
+        const cardId = findCardForSession(session, cardIdBySessionId, cardsByBranch, linksById);
+        if (cardId) {
+            const link = linksById.get(cardId);
+            if (!link)
+                continue;
+            if (!link.sessionLink) {
+                link.sessionLink = { sessionId: session.id, sessionPath: session.jsonlPath };
+                cardIdBySessionId.set(session.id, cardId);
+            }
+            else {
+                link.sessionLink.sessionPath = session.jsonlPath;
+            }
+            link.lastActivity = session.modifiedTime;
+            if (!link.projectPath)
+                link.projectPath = session.projectPath;
+            if (!link.promptBody)
+                link.promptBody = session.firstPrompt;
+        }
+        else {
+            const created = newDiscoveredLink(session);
+            cardIdBySessionId.set(session.id, created.id);
+            if (session.gitBranch) {
+                const base = stripRefsHeads(session.gitBranch);
+                if (!isTrunk(base))
+                    addBranch(base, created.id, false);
+            }
+            linksById.set(created.id, created);
+        }
+    }
+    // A2. index session gitBranch → cards
+    for (const session of sessions) {
+        if (!session.gitBranch)
+            continue;
+        const base = stripRefsHeads(session.gitBranch);
+        if (isTrunk(base))
+            continue;
+        const cardId = cardIdBySessionId.get(session.id);
+        if (cardId)
+            addBranch(base, cardId, true);
+    }
+    // B2. absorb orphan worktree-only cards into real cards on the same branch
+    for (const [branch, cardIds] of [...cardsByBranch.entries()]) {
+        if (cardIds.length <= 1)
+            continue;
+        const orphanIds = cardIds.filter((id) => {
+            const l = linksById.get(id);
+            return l ? !l.sessionLink && l.source !== "manual" && !l.name : false;
+        });
+        if (orphanIds.length === 0)
+            continue;
+        const realIds = cardIds.filter((id) => !orphanIds.includes(id));
+        const keeperId = realIds[0] ?? orphanIds[0];
+        for (const orphanId of orphanIds) {
+            if (orphanId === keeperId)
+                continue;
+            const orphan = linksById.get(orphanId);
+            linksById.delete(orphanId);
+            const keeper = linksById.get(keeperId);
+            if (orphan && keeper && !keeper.worktreeLink)
+                keeper.worktreeLink = orphan.worktreeLink;
+        }
+        cardsByBranch.set(branch, cardIds.filter((id) => !orphanIds.includes(id) || id === keeperId));
+    }
+    const ts = (l) => Date.parse(l.lastActivity ?? l.updatedAt);
+    return [...linksById.values()].sort((a, b) => ts(b) - ts(a));
+}
+// ── Board state ──────────────────────────────────────────────────────────────
+/** Suppress duplicate notifications for one card within this window (62 s). */
+const NOTIFICATION_DEDUP_MS = 62_000;
+/** Discovered sessions idle for longer than this stay off the board (pinned ones excepted). */
+const RECENT_SESSION_MS = 30 * 24 * 60 * 60 * 1000;
+function formatRelativeTime(iso) {
+    const secs = Math.floor((Date.now() - Date.parse(iso)) / 1000);
+    if (secs < 60)
+        return "just now";
+    if (secs < 3600)
+        return `${Math.floor(secs / 60)}m ago`;
+    if (secs < 86400)
+        return `${Math.floor(secs / 3600)}h ago`;
+    const days = Math.floor(secs / 86400);
+    if (days === 1)
+        return "yesterday";
+    if (days < 30)
+        return `${days}d ago`;
+    return `${Math.floor(days / 30)}mo ago`;
+}
+/** Fill `worktreeLink.path` from `git worktree list` for cards that only know a branch. */
+const WORKTREE_CACHE_MS = 30_000;
+const worktreeCache = new Map();
+async function backfillWorktreePaths(links) {
+    // Only roots with a card that still lacks a path need a `git worktree list`.
+    const roots = new Set(links
+        .filter((l) => l.projectPath && l.worktreeLink?.branch && !l.worktreeLink.path)
+        .map((l) => l.projectPath));
+    if (roots.size === 0)
+        return;
+    const byRoot = new Map();
+    for (const root of roots) {
+        const hit = worktreeCache.get(root);
+        if (hit && Date.now() - hit.at < WORKTREE_CACHE_MS) {
+            byRoot.set(root, hit.list);
+            continue;
+        }
+        try {
+            const list = await listWorktrees(root);
+            worktreeCache.set(root, { at: Date.now(), list });
+            byRoot.set(root, list);
+        }
+        catch {
+            // not a git repo — nothing to backfill
+        }
+    }
+    for (const link of links) {
+        const wt = link.worktreeLink;
+        if (!link.projectPath || !wt?.branch || wt.path)
+            continue;
+        const found = byRoot.get(link.projectPath)?.find((w) => w.branch === wt.branch);
+        if (found)
+            wt.path = found.path;
+    }
+}
+export class BoardState {
+    cards = [];
+    lastRefresh = null;
+    prevActivity = new Map();
+    lastNotifiedAt = new Map();
+    tracker = new ActivityTracker();
+    refreshing = null;
+    applyHookEvent(sessionId, eventName, notificationType, at) {
+        const state = activityFromHook(eventName, notificationType);
+        if (!state || !sessionId)
+            return false;
+        this.tracker.applyHook(sessionId, state, at);
+        return true;
+    }
+    /** Coalesces concurrent refreshes — a poll tick and a UI request share one pass. */
+    refresh(discovery, store, projectPaths = []) {
+        if (!this.refreshing) {
+            this.refreshing = this.doRefresh(discovery, store, projectPaths).finally(() => {
+                this.refreshing = null;
+            });
+        }
+        return this.refreshing;
+    }
+    async doRefresh(discovery, store, projectPaths) {
+        const dismissed = await store.readDismissedSessions();
+        const sessions = (await discovery.discoverSessions()).filter((s) => !dismissed.has(s.id));
+        const existing = await store.readLinks();
+        const existingSnapshot = new Map(existing.map((l) => [l.id, { column: l.column, updatedAt: l.updatedAt }]));
+        const all = reconcile(existing, sessions);
+        await backfillWorktreePaths(all);
+        const sessionsById = new Map(sessions.map((s) => [s.id, s]));
+        const activity = new Map();
+        for (const link of all) {
+            const p = link.sessionLink?.sessionPath;
+            if (p && !activity.has(link.id))
+                activity.set(link.id, this.tracker.detect(p, link.sessionLink?.sessionId));
+        }
+        for (const link of all) {
+            updateCardColumn(link, activity.get(link.id), !!link.worktreeLink?.path);
+        }
+        const changed = all.length !== existing.length ||
+            all.some((l) => {
+                const old = existingSnapshot.get(l.id);
+                return !old || old.column !== l.column || old.updatedAt !== l.updatedAt;
+            });
+        if (changed) {
+            // Re-read inside the store lock so concurrent edits (renames, pins…)
+            // made while we were discovering aren't clobbered by our stale copy.
+            await store.update((current) => {
+                const currentById = new Map(current.map((l) => [l.id, l]));
+                const allIds = new Set(all.map((l) => l.id));
+                // Take our reconcile result, but: drop cards deleted since we read,
+                // let cards edited since then win on their user-owned fields, and keep
+                // cards created since then.
+                const merged = all
+                    .filter((l) => currentById.has(l.id) || !existingSnapshot.has(l.id))
+                    .map((l) => {
+                    const cur = currentById.get(l.id);
+                    if (!cur)
+                        return l;
+                    const edited = cur.updatedAt !== existingSnapshot.get(l.id)?.updatedAt;
+                    return edited ? { ...l, ...pickUserFields(cur) } : l;
+                });
+                for (const cur of current) {
+                    if (!allIds.has(cur.id) && !existingSnapshot.has(cur.id))
+                        merged.push(cur);
+                }
+                return merged;
+            });
+        }
+        // Sessions found on disk only get a card once the user has added their
+        // project in Settings, and only while recent. Other cards (manual, issues, …) always show.
+        const recentCutoff = Date.now() - RECENT_SESSION_MS;
+        const visible = all.filter((link) => {
+            if (link.source !== "discovered")
+                return true;
+            if (!link.pinnedAt) {
+                const last = Date.parse(link.lastActivity ?? link.updatedAt);
+                if (Number.isFinite(last) && last < recentCutoff)
+                    return false;
+            }
+            const projectPath = link.projectPath ?? (link.sessionLink && sessionsById.get(link.sessionLink.sessionId)?.projectPath);
+            return isInProject(projectPath, projectPaths);
+        });
+        const cards = visible.map((link) => {
+            const session = link.sessionLink ? sessionsById.get(link.sessionLink.sessionId) : undefined;
+            const act = activity.get(link.id);
+            const title = link.name ? link.name : session ? sessionDisplayTitle(session) : displayTitle(link);
+            const projectPath = link.projectPath ?? session?.projectPath;
+            const projectName = projectPath ? path.basename(projectPath.replace(/[\\/]+$/, "")) : undefined;
+            return {
+                id: link.id,
+                link,
+                session,
+                activityState: act,
+                displayTitle: title,
+                projectName: projectName || undefined,
+                relativeTime: formatRelativeTime(link.lastActivity ?? link.updatedAt),
+                showSpinner: act === "activelyWorking" || link.isLaunching === true,
+            };
+        });
+        this.cards = cards;
+        this.lastRefresh = new Date().toISOString();
+    }
+    toDto() {
+        return { cards: this.cards, lastRefresh: this.lastRefresh ?? undefined };
+    }
+    /** Cards that just went activelyWorking → needsAttention (turn finished). */
+    drainNotificationCandidates() {
+        const now = Date.now();
+        const notify = [];
+        const next = new Map();
+        for (const card of this.cards) {
+            const current = card.activityState ?? "";
+            next.set(card.id, current);
+            const prev = this.prevActivity.get(card.id) ?? "";
+            if ((current === "needsAttention" || current === "idleWaiting") && prev === "activelyWorking") {
+                const last = this.lastNotifiedAt.get(card.id);
+                if (last === undefined || now - last >= NOTIFICATION_DEDUP_MS) {
+                    this.lastNotifiedAt.set(card.id, now);
+                    notify.push(card);
+                }
+            }
+        }
+        this.prevActivity = next;
+        return notify;
+    }
+}
+const normPath = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+/** True when `p` is one of the configured project folders or inside one. */
+export function isInProject(p, projectPaths) {
+    if (!p)
+        return false;
+    const n = normPath(p);
+    return projectPaths.some((root) => {
+        const r = normPath(root);
+        return r !== "" && (n === r || n.startsWith(`${r}/`));
+    });
+}
+function pickUserFields(cur) {
+    return {
+        name: cur.name,
+        manualOverrides: cur.manualOverrides,
+        manuallyArchived: cur.manuallyArchived,
+        column: cur.column,
+        pinnedAt: cur.pinnedAt,
+        pinnedSortOrder: cur.pinnedSortOrder,
+        sortOrder: cur.sortOrder,
+        queuedPrompts: cur.queuedPrompts,
+        browserTabs: cur.browserTabs,
+        cardRuntime: cur.cardRuntime,
+        apiServiceId: cur.apiServiceId,
+        lastOpenedAt: cur.lastOpenedAt,
+        updatedAt: cur.updatedAt,
+    };
+}