@gperezmz/bb-plugin-thread-glance 0.4.0 → 0.4.1

package/dist/server.meta.json

@@ -3,7 +3,7 @@
   "sdkVersion": "0.5.9",
   "artifactFormatVersion": 1,
   "pluginId": "thread-glance",
-  "pluginVersion": "0.4.0",
+  "pluginVersion": "0.4.1",
   "builtWith": {
     "bbVersion": "0.43.4",
     "pluginSdkVersion": "0.5.9"

package/features/thread-list/components/ThreadList.tsx

@@ -39,9 +39,7 @@ import { moveGroup, ORDER_PREFERENCE } from "../model/groups";
 import { MARK_ALL_CONFIRM_ABOVE, type RowMenuAction } from "../model/menu";
 import { assignProviderMarks, providerMark } from "../model/provider-mark";
 import { markAllReadPlan, markReadPlanFor, toggleChip, toggleGroup, toggleOlder, toggleSettled, type ToggleOutcome } from "../model/toggles";
-import { pullRequestFact, pullRequestLookupIds, type SettleInputs } from "../model/settled";
-import { usePullRequestAnswers } from "../data/usePullRequestAnswers";
-import { PullRequestProbes } from "./PullRequestProbes";
+import type { SettleInputs } from "../model/settled";
 import { buildListView, countNeedYou, needYouActive, type GroupView, type ListView } from "../model/view";
 import { shareView } from "../model/share";
 import { ListLiveContext, type ListLive, type ModelInfo, type RowController } from "./controller";
@@ -174,21 +172,15 @@ function ThreadListBody({
     (thread: PluginSidebarThread) => (defaultBranches.has(thread.projectId) ? (defaultBranches.get(thread.projectId) ?? null) : undefined),
     [defaultBranches],
   );
-  const [pullRequests, onPullRequest] = usePullRequestAnswers();
   const system = useSystemFacts();
-  const pullRequestLookups = useMemo(
-    () => (forest === null ? [] : pullRequestLookupIds(forest.infos.values(), defaultBranchOf)),
-    [forest, defaultBranchOf],
-  );
   const settle: SettleInputs = useMemo(
     () => ({
       now,
       settleAfter: prefs.settleAfter,
       startedAt: stamps.startedAt,
       finishedAt: stamps.finishedAt,
-      pullRequestOf: (thread) => pullRequestFact(thread, defaultBranchOf(thread), pullRequests),
     }),
-    [now, prefs.settleAfter, stamps.startedAt, stamps.finishedAt, defaultBranchOf, pullRequests],
+    [now, prefs.settleAfter, stamps.startedAt, stamps.finishedAt],
   );
   // Rows and groups that did not change keep their objects, so their
   // memoized components skip the render.
@@ -723,7 +715,6 @@ function ThreadListBody({
           onPrefs={update}
           onClient={updateClient}
         />
-        <PullRequestProbes threadIds={pullRequestLookups} onAnswer={onPullRequest} />
         {threads.length === 0 ? (
           // bb's own pinned New thread button covers the empty list.
           <p className="px-3 py-4 text-sm text-muted-foreground">No threads yet.</p>

package/features/thread-list/model/settled.ts

@@ -15,46 +15,12 @@ export const SETTLE_AFTER_MS: Readonly<Record<Exclude<SettleAfter, "never">, num
   "1w": 7 * 24 * HOUR,
 };
 
-/** A pull request's state, as bb's lookup reports it. */
-export type PullRequestState = "open" | "draft" | "merged" | "closed";
-
-/**
- * What settling knows of a thread's pull request: its state, null when the
- * thread has none, or `unknown` while a lookup it needs has not answered.
- */
-export type PullRequestFact = PullRequestState | null | "unknown";
-
-/**
- * Whether a thread's branch can carry a pull request worth looking up: it is
- * on a branch other than its project's default. A default branch the lookup
- * could not find (null) is no reason to skip one; one still being looked up
- * (undefined) is, until it answers.
- */
-export function needsPullRequestLookup(branch: string | null, defaultBranch: string | null | undefined): boolean {
-  return branch !== null && defaultBranch !== undefined && branch !== defaultBranch;
-}
-
-/** A thread's pull request fact, from its project's default branch and the lookups that answered. */
-export function pullRequestFact(
-  thread: Pick<PluginSidebarThread, "id" | "environment">,
-  defaultBranch: string | null | undefined,
-  answers: ReadonlyMap<string, PullRequestState | null>,
-): PullRequestFact {
-  const branch = thread.environment?.branchName ?? null;
-  if (branch === null) return null;
-  if (defaultBranch === undefined) return "unknown";
-  if (!needsPullRequestLookup(branch, defaultBranch)) return null;
-  const answer = answers.get(thread.id);
-  return answer === undefined ? "unknown" : answer;
-}
-
 export interface SettleInputs {
   now: number;
   settleAfter: SettleAfter;
   /** Server stamps: when each thread last started and finished a turn. */
   startedAt: Readonly<Record<string, number>>;
   finishedAt: Readonly<Record<string, number>>;
-  pullRequestOf(thread: PluginSidebarThread): PullRequestFact;
 }
 
 /**
@@ -77,46 +43,18 @@ export function lastActivityAt(
 
 /**
  * A settled thread: quiet as if no thread were open, not needing attention,
- * not pinned, with no open pull request, and either its pull request merged
- * or closed or its own last activity is older than the Settle after period.
- * Hidden and archived threads take the same test.
+ * not pinned, and its own last activity is older than the Settle after
+ * period. Hidden and archived threads take the same test.
  */
 export function isSettledThread(info: ThreadInfo, inputs: SettleInputs): boolean {
   const thread = info.thread;
-  if (!mightSettle(info)) return false;
-  const pullRequest = inputs.pullRequestOf(thread);
-  if (pullRequest === "unknown" || pullRequest === "open" || pullRequest === "draft") return false;
-  if (pullRequest === "merged" || pullRequest === "closed") return true;
+  if (thread.pinnedAt !== null || thread.isPinned) return false;
+  if (!isQuietThread(info.state, info.unread, false) || info.attentionFlags.size > 0) return false;
   if (inputs.settleAfter === "never") return false;
   return inputs.now - lastActivityAt(thread, inputs) >= SETTLE_AFTER_MS[inputs.settleAfter];
 }
 
-/** A row's thread that settles once its pull request and activity allow: quiet as if none were open, needing no attention, not pinned. */
-function mightSettle(info: ThreadInfo): boolean {
-  const thread = info.thread;
-  if (thread.pinnedAt !== null || thread.isPinned) return false;
-  return isQuietThread(info.state, info.unread, false) && info.attentionFlags.size === 0;
-}
-
 /** A tree settles as one unit: when every thread in it is settled. */
 export function isSettledTree(tree: Pick<ThreadTree, "root" | "descendants">, inputs: SettleInputs): boolean {
   return isSettledThread(tree.root, inputs) && tree.descendants.every((info) => isSettledThread(info, inputs));
 }
-
-/**
- * The threads whose pull request settling has to look up: every thread that
- * would settle but for its pull request, on a branch other than its
- * project's default.
- */
-export function pullRequestLookupIds(
-  infos: Iterable<ThreadInfo>,
-  defaultBranchOf: (thread: PluginSidebarThread) => string | null | undefined,
-): string[] {
-  const ids: string[] = [];
-  for (const info of infos) {
-    const thread = info.thread;
-    if (!mightSettle(info)) continue;
-    if (needsPullRequestLookup(thread.environment?.branchName ?? null, defaultBranchOf(thread))) ids.push(thread.id);
-  }
-  return ids;
-}

package/features/thread-list/testing/fixtures.ts

@@ -8,7 +8,7 @@ import { defaultPreferences, type Preferences } from "@/shared/preferences";
 import { buildForest, type Forest } from "../model/trees";
 import { buildListView, type ListView, type Row } from "../model/view";
 import type { Targets } from "../model/expansion";
-import { pullRequestFact, type PullRequestState, type SettleInputs } from "../model/settled";
+import type { SettleInputs } from "../model/settled";
 
 export const T0 = 1_780_000_000_000;
 
@@ -125,8 +125,6 @@ export interface Scenario {
   needYouOnly?: boolean;
   /** bb's default harness; "claude-code", the fixtures' own, when absent. */
   defaultProviderId?: string | null;
-  /** Pull request lookups that answered, by thread id. */
-  pullRequests?: Record<string, PullRequestState | null>;
 }
 
 export function forestOf(scenario: Scenario): Forest {
@@ -165,15 +163,11 @@ export function viewOf(scenario: Scenario): ListView {
 
 /** The settle inputs a scenario stands for. */
 export function settleOf(scenario: Scenario): SettleInputs {
-  const answers = new Map(Object.entries(scenario.pullRequests ?? {}));
-  const defaultBranchOf = (projectId: string) =>
-    scenario.defaultBranches === undefined ? "main" : scenario.defaultBranches[projectId];
   return {
     now: scenario.now ?? T0 + 60_000,
     settleAfter: scenario.prefs?.settleAfter ?? defaultPreferences().settleAfter,
     startedAt: scenario.startedAt ?? {},
     finishedAt: scenario.finishedAt ?? {},
-    pullRequestOf: (thread) => pullRequestFact(thread, defaultBranchOf(thread.projectId), answers),
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gperezmz/bb-plugin-thread-glance",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "type": "module",
   "engines": {
     "bb": ">=0.43",

package/skills/thread-glance/SKILL.md

@@ -52,7 +52,7 @@ and `bb environment list`; a thread id is a `thr_…` id.
 | `collapsedThreadSections` | Custom section keys, `section:<id>` | `[]` |
 | `collapsedMachines` | Machine ids | `[]` |
 | `collapsedEnvironments` | Environment ids of collapsed folder rows | `[]` |
-| `settleAfter` | Settle after: how long a quiet thread goes without activity before its tree can settle into the group's "Settled (N)" fold: `12h`, `1d`, `3d`, `1w` or `never` (then only a merged or closed pull request settles it) | `1d` |
+| `settleAfter` | Settle after: how long a quiet thread goes without activity before its tree can settle into the group's "Settled (N)" fold: `12h`, `1d`, `3d`, `1w` or `never` (then nothing settles) | `1d` |
 | `openSettledFolds` | Group ids whose settled fold is open | `[]` |
 | `expandedOlder` | Parent thread ids whose "N more child threads" row is open, once that tree's children chip is open | `[]` |
 | `expandedChildren` | Parent thread ids whose chip is open | `[]` |

package/features/thread-list/components/PullRequestProbes.tsx

@@ -1,27 +0,0 @@
-// Looks up the pull request of every thread settling has to know about and
-// reports each answer. Draws nothing: the host shares one lookup per
-// environment with the badges that ask for the same threads.
-import { memo, useEffect } from "react";
-import { experimental_useSidebarThreadPullRequest as usePullRequest } from "@get-bb/plugin-sdk/app";
-import type { PullRequestState } from "../model/settled";
-
-type Answer = (threadId: string, state: PullRequestState | null) => void;
-
-const Probe = memo(function Probe({ threadId, onAnswer }: { threadId: string; onAnswer: Answer }) {
-  const { isLoading, pullRequest } = usePullRequest(threadId);
-  const state = isLoading ? undefined : (pullRequest?.state ?? null);
-  useEffect(() => {
-    if (state !== undefined) onAnswer(threadId, state);
-  }, [threadId, state, onAnswer]);
-  return null;
-});
-
-export function PullRequestProbes({ threadIds, onAnswer }: { threadIds: readonly string[]; onAnswer: Answer }) {
-  return (
-    <>
-      {threadIds.map((threadId) => (
-        <Probe key={threadId} threadId={threadId} onAnswer={onAnswer} />
-      ))}
-    </>
-  );
-}

package/features/thread-list/data/usePullRequestAnswers.ts

@@ -1,36 +0,0 @@
-// The pull request lookups that answered, by thread id. Answers arriving in
-// one burst (a list's worth of lookups on load) land in one state update.
-//
-// Debt: this copies server state the host's per-row pull request hook owns,
-// because settling reads every thread's pull request at once and the SDK
-// offers no query over many threads. It clears when the SDK does.
-import { useCallback, useRef, useState } from "react";
-import type { PullRequestState } from "../model/settled";
-
-export type PullRequestAnswers = ReadonlyMap<string, PullRequestState | null>;
-
-export function usePullRequestAnswers(): [PullRequestAnswers, (threadId: string, state: PullRequestState | null) => void] {
-  const [answers, setAnswers] = useState<PullRequestAnswers>(() => new Map());
-  const pending = useRef(new Map<string, PullRequestState | null>());
-  const scheduled = useRef(false);
-  const onAnswer = useCallback((threadId: string, state: PullRequestState | null) => {
-    pending.current.set(threadId, state);
-    if (scheduled.current) return;
-    scheduled.current = true;
-    setTimeout(() => {
-      scheduled.current = false;
-      const batch = pending.current;
-      pending.current = new Map();
-      setAnswers((current) => {
-        let next: Map<string, PullRequestState | null> | null = null;
-        for (const [id, value] of batch) {
-          if (current.has(id) && current.get(id) === value) continue;
-          next ??= new Map(current);
-          next.set(id, value);
-        }
-        return next ?? current;
-      });
-    }, 0);
-  }, []);
-  return [answers, onAnswer];
-}