@worca/ui 0.31.0 → 0.33.0

package/server/ws-beads-watcher.js

@@ -6,7 +6,11 @@
 
 import { existsSync, statSync, unwatchFile, watch, watchFile } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { countIssuesByRunLabel, listIssues } from './beads-reader.js';
+import {
+  countIssuesByRunLabel,
+  enrichIssuesWithDeps,
+  listIssuesShallow,
+} from './beads-reader.js';
 
 const BEADS_DEBOUNCE_MS = 500;
 const BEADS_POLL_MS = 2000;
@@ -34,19 +38,73 @@ export function createBeadsWatcher({ worcaDir, broadcaster, projectId }) {
   let lastPayloadJson = null;
   let lastSelfReadWalStat = null;
   let latestCounts = {};
+  // In-flight guard + trailing coalesce. The refresh body spawns several `bd`
+  // subprocesses (listIssuesShallow, then enrichIssuesWithDeps +
+  // countIssuesByRunLabel when the fingerprint changes) that, on a large beads
+  // db, take seconds. The debounce only collapses scheduling — once the async body
+  // is awaiting, a fresh db/WAL event would otherwise start an overlapping
+  // refresh and pile up bd processes unbounded. Allow at most one refresh in
+  // flight; events arriving mid-refresh collapse into a single trailing pass.
+  let refreshing = false;
+  let refreshPending = false;
+  let lastListFingerprint = null;
+
+  function computeFingerprint(issues) {
+    const sorted = [...issues].sort((a, b) => (a.id < b.id ? -1 : 1));
+    return JSON.stringify(
+      sorted.map((i) => ({
+        id: i.id,
+        status: i.status,
+        priority: i.priority,
+        title: i.title,
+        updated_at: i.updated_at,
+        // dependency_count/dependent_count come free in `bd list` (no `bd show`).
+        // They catch dependency-edge changes (`bd dep add/remove`) that don't
+        // bump an issue's own updated_at — without them the fingerprint would
+        // bail and leave depends_on/blocked_by (and blocked badges) stale.
+        dependency_count: i.dependency_count,
+        dependent_count: i.dependent_count,
+      })),
+    );
+  }
+
+  function recordWalStat() {
+    try {
+      const s = statSync(beadsWalPath);
+      lastSelfReadWalStat = { mtimeMs: s.mtimeMs, size: s.size };
+    } catch {
+      lastSelfReadWalStat = null;
+    }
+  }
 
   function scheduleBeadsRefresh() {
     if (BEADS_REFRESH_TIMER) clearTimeout(BEADS_REFRESH_TIMER);
-    BEADS_REFRESH_TIMER = setTimeout(async () => {
-      BEADS_REFRESH_TIMER = null;
-      try {
-        const [issues, counts] = await Promise.all([
-          listIssues(beadsDbPath),
-          countIssuesByRunLabel(beadsDbPath).catch(() => ({})),
-        ]);
-        latestCounts = counts;
-        const payloadJson = JSON.stringify({ issues, counts });
-        if (payloadJson === lastPayloadJson) return;
+    BEADS_REFRESH_TIMER = setTimeout(runBeadsRefresh, BEADS_DEBOUNCE_MS);
+  }
+
+  async function runBeadsRefresh() {
+    BEADS_REFRESH_TIMER = null;
+    if (refreshing) {
+      refreshPending = true;
+      return;
+    }
+    refreshing = true;
+    try {
+      const shallowIssues = await listIssuesShallow(beadsDbPath);
+      const fingerprint = computeFingerprint(shallowIssues);
+      if (fingerprint === lastListFingerprint) {
+        recordWalStat();
+        return;
+      }
+      lastListFingerprint = fingerprint;
+
+      const [issues, counts] = await Promise.all([
+        enrichIssuesWithDeps(shallowIssues, beadsDbPath),
+        countIssuesByRunLabel(beadsDbPath).catch(() => ({})),
+      ]);
+      latestCounts = counts;
+      const payloadJson = JSON.stringify({ issues, counts });
+      if (payloadJson !== lastPayloadJson) {
         lastPayloadJson = payloadJson;
         broadcaster.broadcast(
           'beads-update',
@@ -58,16 +116,17 @@ export function createBeadsWatcher({ worcaDir, broadcaster, projectId }) {
           },
           projectId,
         );
-        try {
-          const s = statSync(beadsWalPath);
-          lastSelfReadWalStat = { mtimeMs: s.mtimeMs, size: s.size };
-        } catch {
-          lastSelfReadWalStat = null;
-        }
-      } catch {
-        /* ignore */
       }
-    }, BEADS_DEBOUNCE_MS);
+      recordWalStat();
+    } catch {
+      /* ignore */
+    } finally {
+      refreshing = false;
+      if (refreshPending) {
+        refreshPending = false;
+        scheduleBeadsRefresh();
+      }
+    }
   }
 
   if (existsSync(beadsDir)) {
@@ -116,7 +175,11 @@ export function createBeadsWatcher({ worcaDir, broadcaster, projectId }) {
   return { getBeadsDbPath, getLatestCounts, destroy };
 }
 
-const FALLBACK_TTL_MS = 5000;
+// Throttle window for the cold-path bead-count read (used by REST /runs and chat
+// when no live watcher is warm). The read costs seconds on a large db, so a short
+// TTL lets repeated /runs across many projects re-spawn `bd` too often. Counts are
+// advisory and the live watcher keeps a viewed project fresh, so 30s is ample.
+const FALLBACK_TTL_MS = 30000;
 /** @type {Map<string, { ts: number, counts: object }>} */
 const fallbackCache = new Map();
 /** @type {Map<string, Promise<object>>} */
@@ -163,3 +226,50 @@ export async function resolveBeadsCounts(wset) {
   fallbackInflight.set(key, promise);
   return promise;
 }
+
+/**
+ * Non-blocking variant of {@link resolveBeadsCounts}: returns whatever counts
+ * are already available (the live watcher cache, or a fresh TTL-cached fallback)
+ * WITHOUT ever awaiting the cold `bd` query. When nothing is cached it kicks off
+ * a background refresh (reusing the same TTL cache + in-flight dedup) so a later
+ * caller gets real data, and returns {} immediately.
+ *
+ * Used by the REST `/runs` endpoint: a cold `bd show` on a large beads db
+ * (worca-cc has hundreds of issues — the cold read takes ~10s) would otherwise
+ * block the run list and, fanned out across every project, stall the whole UI.
+ * Bead counts on run cards are advisory and arrive via the `beads-update`
+ * broadcast once warm; the web run-detail does not use them at all.
+ *
+ * @param {{ projectId?: string, worcaDir?: string, beadsWatcher?: { getLatestCounts: () => object } | null }} [wset]
+ * @returns {Record<string, { total: number, done: number }>}
+ */
+export function peekBeadsCounts(wset) {
+  if (!wset || !wset.worcaDir) return {};
+
+  const live = wset.beadsWatcher?.getLatestCounts();
+  if (live && Object.keys(live).length > 0) return live;
+
+  const key = wset.projectId ?? wset.worcaDir;
+  const cached = fallbackCache.get(key);
+  if (cached && Date.now() - cached.ts < FALLBACK_TTL_MS) return cached.counts;
+
+  // Cold cache: warm it in the background (dedup'd), but never block the caller.
+  if (!fallbackInflight.has(key)) {
+    const dbPath = beadsDbPathFor(wset.worcaDir);
+    if (existsSync(dbPath)) {
+      const promise = (async () => {
+        try {
+          const counts = await countIssuesByRunLabel(dbPath);
+          fallbackCache.set(key, { ts: Date.now(), counts });
+          return counts;
+        } catch {
+          return {};
+        } finally {
+          fallbackInflight.delete(key);
+        }
+      })();
+      fallbackInflight.set(key, promise);
+    }
+  }
+  return {};
+}

package/server/ws-modular.js

@@ -13,7 +13,7 @@ import { fleetRunsDir, workspaceRunsDir } from './paths.js';
 import { readProjects, synthesizeDefaultProject } from './project-registry.js';
 import { TIER_FULL, TIER_POLLING, WatcherSet } from './watcher-set.js';
 import { readProjectWorcaVersion } from './worca-setup.js';
-import { resolveBeadsCounts } from './ws-beads-watcher.js';
+import { peekBeadsCounts } from './ws-beads-watcher.js';
 import { createBroadcaster } from './ws-broadcaster.js';
 import { createClientManager } from './ws-client-manager.js';
 import { createFleetManifestWatcher } from './ws-fleet-manifest-watcher.js';
@@ -331,8 +331,10 @@ export function attachWsServer(httpServer, config) {
     return null;
   }
 
+  // Non-blocking: returns cached/live counts and warms cold caches in the
+  // background. The REST /runs endpoint must never block on a slow `bd` read.
   function getBeadsCounts(projectId) {
-    return resolveBeadsCounts(watcherSets.get(projectId));
+    return peekBeadsCounts(watcherSets.get(projectId));
   }
 
   return {