Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
feat(web): add shift-click multi-select for sidebar threads (#651)
0x1f99dafb6e89bfdd9
diff --git a/apps/web/src/components/Sidebar.logic.test.ts b/apps/web/src/components/Sidebar.logic.test.tsindex d0216d0e4..634d91e9d 100644--- a/apps/web/src/components/Sidebar.logic.test.ts+++ b/apps/web/src/components/Sidebar.logic.test.ts@@ -1,6 +1,10 @@import { describe, expect, it } from "vitest";-import { hasUnseenCompletion, resolveThreadStatusPill } from "./Sidebar.logic";+import {+ hasUnseenCompletion,+ resolveThreadStatusPill,+ shouldClearThreadSelectionOnMouseDown,+} from "./Sidebar.logic";function makeLatestTurn(overrides?: {completedAt?: string | null;@@ -30,6 +34,34 @@ describe("hasUnseenCompletion", () => {});});+describe("shouldClearThreadSelectionOnMouseDown", () => {+ it("preserves selection for thread items", () => {+ const child = {+ closest: (selector: string) =>+ selector.includes("[data-thread-item]") ? ({} as Element) : null,+ } as unknown as HTMLElement;++ expect(shouldClearThreadSelectionOnMouseDown(child)).toBe(false);+ });++ it("preserves selection for thread list toggle controls", () => {+ const selectionSafe = {+ closest: (selector: string) =>+ selector.includes("[data-thread-selection-safe]") ? ({} as Element) : null,+ } as unknown as HTMLElement;++ expect(shouldClearThreadSelectionOnMouseDown(selectionSafe)).toBe(false);+ });++ it("clears selection for unrelated sidebar clicks", () => {+ const unrelated = {+ closest: () => null,+ } as unknown as HTMLElement;++ expect(shouldClearThreadSelectionOnMouseDown(unrelated)).toBe(true);+ });+});+describe("resolveThreadStatusPill", () => {const baseThread = {interactionMode: "plan" as const,diff --git a/apps/web/src/components/Sidebar.logic.ts b/apps/web/src/components/Sidebar.logic.tsindex e950d8de6..379d7b60e 100644--- a/apps/web/src/components/Sidebar.logic.ts+++ b/apps/web/src/components/Sidebar.logic.ts@@ -1,6 +1,9 @@import type { Thread } from "../types";import { findLatestProposedPlan, isLatestTurnSettled } from "../session-logic";+export const THREAD_SELECTION_SAFE_SELECTOR =+ "[data-thread-item], [data-thread-selection-safe]";+export interface ThreadStatusPill {label:| "Working"@@ -30,6 +33,11 @@ export function hasUnseenCompletion(thread: ThreadStatusInput): boolean {return completedAt > lastVisitedAt;}+export function shouldClearThreadSelectionOnMouseDown(target: HTMLElement | null): boolean {+ if (target === null) return true;+ return !target.closest(THREAD_SELECTION_SAFE_SELECTOR);+}+export function resolveThreadStatusPill(input: {thread: ThreadStatusInput;hasPendingApprovals: boolean;diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsxindex 284ed0da9..88e9d674b 100644--- a/apps/web/src/components/Sidebar.tsx+++ b/apps/web/src/components/Sidebar.tsx@@ -10,7 +10,7 @@ import {TerminalIcon,TriangleAlertIcon,} from "lucide-react";-import { useCallback, useEffect, useMemo, useRef, useState } from "react";+import { useCallback, useEffect, useMemo, useRef, useState, type MouseEvent } from "react";import {DndContext,type DragCancelEvent,@@ -40,7 +40,7 @@ import { useLocation, useNavigate, useParams } from "@tanstack/react-router";import { useAppSettings } from "../appSettings";import { isElectron } from "../env";import { APP_STAGE_LABEL } from "../branding";-import { newCommandId, newProjectId, newThreadId } from "../lib/utils";+import { isMacPlatform, newCommandId, newProjectId, newThreadId } from "../lib/utils";import { useStore } from "../store";import { isChatNewLocalShortcut, isChatNewShortcut, shortcutLabelForCommand } from "../keybindings";import { derivePendingApprovals, derivePendingUserInputs } from "../session-logic";@@ -80,9 +80,13 @@ import {SidebarSeparator,SidebarTrigger,} from "./ui/sidebar";+import { useThreadSelectionStore } from "../threadSelectionStore";import { formatWorktreePathForDisplay, getOrphanedWorktreePathForThread } from "../worktreeCleanup";import { isNonEmpty as isNonEmptyString } from "effect/String";-import { resolveThreadStatusPill } from "./Sidebar.logic";+import {+ resolveThreadStatusPill,+ shouldClearThreadSelectionOnMouseDown,+} from "./Sidebar.logic";const EMPTY_KEYBINDINGS: ResolvedKeybindingsConfig = [];const THREAD_PREVIEW_LIMIT = 6;@@ -301,6 +305,12 @@ export default function Sidebar() {const dragInProgressRef = useRef(false);const suppressProjectClickAfterDragRef = useRef(false);const [desktopUpdateState, setDesktopUpdateState] = useState<DesktopUpdateState | null>(null);+ const selectedThreadIds = useThreadSelectionStore((s) => s.selectedThreadIds);+ const toggleThreadSelection = useThreadSelectionStore((s) => s.toggleThread);+ const rangeSelectTo = useThreadSelectionStore((s) => s.rangeSelectTo);+ const clearSelection = useThreadSelectionStore((s) => s.clearSelection);+ const removeFromSelection = useThreadSelectionStore((s) => s.removeFromSelection);+ const setSelectionAnchor = useThreadSelectionStore((s) => s.setAnchor);const shouldBrowseForProjectImmediately = isElectron;const shouldShowProjectPathEntry = addingProject && !shouldBrowseForProjectImmediately;const pendingApprovalByThreadId = useMemo(() => {@@ -628,64 +638,31 @@ export default function Sidebar() {[],);- const handleThreadContextMenu = useCallback(- async (threadId: ThreadId, position: { x: number; y: number }) => {+ /**+ * Delete a single thread: stop session, close terminal, dispatch delete,+ * clean up drafts/state, and optionally remove orphaned worktree.+ * Callers handle thread-level confirmation; this still prompts for worktree removal.+ */+ const deleteThread = useCallback(+ async (+ threadId: ThreadId,+ opts: { deletedThreadIds?: ReadonlySet<ThreadId> } = {},+ ): Promise<void> => {const api = readNativeApi();if (!api) return;- const clicked = await api.contextMenu.show(- [- { id: "rename", label: "Rename thread" },- { id: "mark-unread", label: "Mark unread" },- { id: "copy-thread-id", label: "Copy Thread ID" },- { id: "delete", label: "Delete", destructive: true },- ],- position,- );const thread = threads.find((t) => t.id === threadId);if (!thread) return;- if (clicked === "rename") {- setRenamingThreadId(threadId);- setRenamingTitle(thread.title);- renamingCommittedRef.current = false;- return;- }-- if (clicked === "mark-unread") {- markThreadUnread(threadId);- return;- }- if (clicked === "copy-thread-id") {- try {- await copyTextToClipboard(threadId);- toastManager.add({- type: "success",- title: "Thread ID copied",- description: threadId,- });- } catch (error) {- toastManager.add({- type: "error",- title: "Failed to copy thread ID",- description: error instanceof Error ? error.message : "An error occurred.",- });- }- return;- }- if (clicked !== "delete") return;- if (appSettings.confirmThreadDelete) {- const confirmed = await api.dialogs.confirm(- [- `Delete thread "${thread.title}"?`,- "This permanently clears conversation history for this thread.",- ].join("\n"),- );- if (!confirmed) {- return;- }- }const threadProject = projects.find((project) => project.id === thread.projectId);- const orphanedWorktreePath = getOrphanedWorktreePathForThread(threads, threadId);+ // When bulk-deleting, exclude the other threads being deleted so+ // getOrphanedWorktreePathForThread correctly detects that no surviving+ // threads will reference this worktree.+ const deletedIds = opts.deletedThreadIds;+ const survivingThreads =+ deletedIds && deletedIds.size > 0+ ? threads.filter((t) => t.id === threadId || !deletedIds.has(t.id))+ : threads;+ const orphanedWorktreePath = getOrphanedWorktreePathForThread(survivingThreads, threadId);const displayWorktreePath = orphanedWorktreePath? formatWorktreePathForDisplay(orphanedWorktreePath): null;@@ -713,16 +690,15 @@ export default function Sidebar() {}try {- await api.terminal.close({- threadId,- deleteHistory: true,- });+ await api.terminal.close({ threadId, deleteHistory: true });} catch {// Terminal may already be closed}+ const allDeletedIds = deletedIds ?? new Set<ThreadId>();const shouldNavigateToFallback = routeThreadId === threadId;- const fallbackThreadId = threads.find((entry) => entry.id !== threadId)?.id ?? null;+ const fallbackThreadId =+ threads.find((entry) => entry.id !== threadId && !allDeletedIds.has(entry.id))?.id ?? null;await api.orchestration.dispatchCommand({type: "thread.delete",commandId: newCommandId(),@@ -769,11 +745,9 @@ export default function Sidebar() {}},[- appSettings.confirmThreadDelete,clearComposerDraftForThread,clearProjectDraftThreadById,clearTerminalState,- markThreadUnread,navigate,projects,removeWorktreeMutation,@@ -782,6 +756,150 @@ export default function Sidebar() {],);+ const handleThreadContextMenu = useCallback(+ async (threadId: ThreadId, position: { x: number; y: number }) => {+ const api = readNativeApi();+ if (!api) return;+ const clicked = await api.contextMenu.show(+ [+ { id: "rename", label: "Rename thread" },+ { id: "mark-unread", label: "Mark unread" },+ { id: "copy-thread-id", label: "Copy Thread ID" },+ { id: "delete", label: "Delete", destructive: true },+ ],+ position,+ );+ const thread = threads.find((t) => t.id === threadId);+ if (!thread) return;++ if (clicked === "rename") {+ setRenamingThreadId(threadId);+ setRenamingTitle(thread.title);+ renamingCommittedRef.current = false;+ return;+ }++ if (clicked === "mark-unread") {+ markThreadUnread(threadId);+ return;+ }+ if (clicked === "copy-thread-id") {+ try {+ await copyTextToClipboard(threadId);+ toastManager.add({+ type: "success",+ title: "Thread ID copied",+ description: threadId,+ });+ } catch (error) {+ toastManager.add({+ type: "error",+ title: "Failed to copy thread ID",+ description: error instanceof Error ? error.message : "An error occurred.",+ });+ }+ return;+ }+ if (clicked !== "delete") return;+ if (appSettings.confirmThreadDelete) {+ const confirmed = await api.dialogs.confirm(+ [+ `Delete thread "${thread.title}"?`,+ "This permanently clears conversation history for this thread.",+ ].join("\n"),+ );+ if (!confirmed) {+ return;+ }+ }+ await deleteThread(threadId);+ },+ [appSettings.confirmThreadDelete, deleteThread, markThreadUnread, threads],+ );++ const handleMultiSelectContextMenu = useCallback(+ async (position: { x: number; y: number }) => {+ const api = readNativeApi();+ if (!api) return;+ const ids = [...selectedThreadIds];+ if (ids.length === 0) return;+ const count = ids.length;++ const clicked = await api.contextMenu.show(+ [+ { id: "mark-unread", label: `Mark unread (${count})` },+ { id: "delete", label: `Delete (${count})`, destructive: true },+ ],+ position,+ );++ if (clicked === "mark-unread") {+ for (const id of ids) {+ markThreadUnread(id);+ }+ clearSelection();+ return;+ }++ if (clicked !== "delete") return;++ if (appSettings.confirmThreadDelete) {+ const confirmed = await api.dialogs.confirm(+ [+ `Delete ${count} thread${count === 1 ? "" : "s"}?`,+ "This permanently clears conversation history for these threads.",+ ].join("\n"),+ );+ if (!confirmed) return;+ }++ const deletedIds = new Set<ThreadId>(ids);+ for (const id of ids) {+ await deleteThread(id, { deletedThreadIds: deletedIds });+ }+ removeFromSelection(ids);+ },+ [+ appSettings.confirmThreadDelete,+ clearSelection,+ deleteThread,+ markThreadUnread,+ removeFromSelection,+ selectedThreadIds,+ ],+ );++ const handleThreadClick = useCallback(+ (event: MouseEvent, threadId: ThreadId, orderedProjectThreadIds: readonly ThreadId[]) => {+ const isMac = isMacPlatform(navigator.platform);+ const isModClick = isMac ? event.metaKey : event.ctrlKey;+ const isShiftClick = event.shiftKey;++ if (isModClick) {+ event.preventDefault();+ toggleThreadSelection(threadId);+ return;+ }++ if (isShiftClick) {+ event.preventDefault();+ rangeSelectTo(threadId, orderedProjectThreadIds);+ return;+ }++ // Plain click — clear selection, set anchor for future shift-clicks, and navigate+ if (selectedThreadIds.size > 0) {+ clearSelection();+ }+ setSelectionAnchor(threadId);+ void navigate({+ to: "/$threadId",+ params: { threadId },+ });+ },+ [clearSelection, navigate, rangeSelectTo, selectedThreadIds.size, setSelectionAnchor, toggleThreadSelection],+ );+const handleProjectContextMenu = useCallback(async (projectId: ProjectId, position: { x: number; y: number }) => {const api = readNativeApi();@@ -894,9 +1012,12 @@ export default function Sidebar() {event.stopPropagation();return;}+ if (selectedThreadIds.size > 0) {+ clearSelection();+ }toggleProject(projectId);},- [toggleProject],+ [clearSelection, selectedThreadIds.size, toggleProject],);const handleProjectTitleKeyDown = useCallback(@@ -913,6 +1034,12 @@ export default function Sidebar() {useEffect(() => {const onWindowKeyDown = (event: KeyboardEvent) => {+ if (event.key === "Escape" && selectedThreadIds.size > 0) {+ event.preventDefault();+ clearSelection();+ return;+ }+const activeThread = routeThreadId? threads.find((thread) => thread.id === routeThreadId): undefined;@@ -937,11 +1064,20 @@ export default function Sidebar() {});};+ const onMouseDown = (event: globalThis.MouseEvent) => {+ if (selectedThreadIds.size === 0) return;+ const target = event.target instanceof HTMLElement ? event.target : null;+ if (!shouldClearThreadSelectionOnMouseDown(target)) return;+ clearSelection();+ };+window.addEventListener("keydown", onWindowKeyDown);+ window.addEventListener("mousedown", onMouseDown);return () => {window.removeEventListener("keydown", onWindowKeyDown);+ window.removeEventListener("mousedown", onMouseDown);};- }, [getDraftThread, handleNewThread, keybindings, projects, routeThreadId, threads]);+ }, [clearSelection, getDraftThread, handleNewThread, keybindings, projects, routeThreadId, selectedThreadIds.size, threads]);useEffect(() => {if (!isElectron) return;@@ -1277,6 +1413,7 @@ export default function Sidebar() {hasHiddenThreads && !isThreadListExpanded? projectThreads.slice(0, THREAD_PREVIEW_LIMIT): projectThreads;+ const orderedProjectThreadIds = projectThreads.map((t) => t.id);return (<SortableProjectItem key={project.id} projectId={project.id}>@@ -1343,9 +1480,11 @@ export default function Sidebar() {</div><CollapsibleContent keepMounted>- <SidebarMenuSub className="mx-1 my-0 w-full translate-x-0 gap-0 px-1.5 py-0">+ <SidebarMenuSub className="mx-1 my-0 w-full translate-x-0 gap-0.5 px-1.5 py-0">{visibleThreads.map((thread) => {const isActive = routeThreadId === thread.id;+ const isSelected = selectedThreadIds.has(thread.id);+ const isHighlighted = isActive || isSelected;const threadStatus = resolveThreadStatusPill({thread,hasPendingApprovals: pendingApprovalByThreadId.get(thread.id) === true,@@ -1358,25 +1497,28 @@ export default function Sidebar() {);return (- <SidebarMenuSubItem key={thread.id} className="w-full">+ <SidebarMenuSubItem key={thread.id} className="w-full" data-thread-item><SidebarMenuSubButtonrender={<div role="button" tabIndex={0} />}size="sm"isActive={isActive}- className={`h-7 w-full translate-x-0 cursor-default justify-start px-2 text-left hover:bg-accent hover:text-foreground ${- isActive- ? "bg-accent/85 text-foreground font-medium ring-1 ring-border/70 dark:bg-accent/55 dark:ring-border/50"- : "text-muted-foreground"+ className={`h-7 w-full translate-x-0 cursor-default justify-start px-2 text-left select-none hover:bg-accent hover:text-foreground focus-visible:ring-0 ${+ isSelected+ ? "bg-primary/15 text-foreground dark:bg-primary/10"+ : isActive+ ? "bg-accent/85 text-foreground font-medium dark:bg-accent/55"+ : "text-muted-foreground"}`}- onClick={() => {- void navigate({- to: "/$threadId",- params: { threadId: thread.id },- });+ onClick={(event) => {+ handleThreadClick(event, thread.id, orderedProjectThreadIds);}}onKeyDown={(event) => {if (event.key !== "Enter" && event.key !== " ") return;event.preventDefault();+ if (selectedThreadIds.size > 0) {+ clearSelection();+ }+ setSelectionAnchor(thread.id);void navigate({to: "/$threadId",params: { threadId: thread.id },@@ -1384,10 +1526,20 @@ export default function Sidebar() {}}onContextMenu={(event) => {event.preventDefault();- void handleThreadContextMenu(thread.id, {- x: event.clientX,- y: event.clientY,- });+ if (selectedThreadIds.size > 0 && selectedThreadIds.has(thread.id)) {+ void handleMultiSelectContextMenu({+ x: event.clientX,+ y: event.clientY,+ });+ } else {+ if (selectedThreadIds.size > 0) {+ clearSelection();+ }+ void handleThreadContextMenu(thread.id, {+ x: event.clientX,+ y: event.clientY,+ });+ }}}><div className="flex min-w-0 flex-1 items-center gap-1.5 text-left">@@ -1474,7 +1626,7 @@ export default function Sidebar() {)}<spanclassName={`text-[10px] ${- isActive ? "text-foreground/65" : "text-muted-foreground/40"+ isHighlighted ? "text-foreground/65" : "text-muted-foreground/40"}`}>{formatRelativeTime(thread.createdAt)}@@ -1489,6 +1641,7 @@ export default function Sidebar() {<SidebarMenuSubItem className="w-full"><SidebarMenuSubButtonrender={<button type="button" />}+ data-thread-selection-safesize="sm"className="h-6 w-full translate-x-0 justify-start px-2 text-left text-[10px] text-muted-foreground/60 hover:bg-accent hover:text-muted-foreground/80"onClick={() => {@@ -1503,6 +1656,7 @@ export default function Sidebar() {<SidebarMenuSubItem className="w-full"><SidebarMenuSubButtonrender={<button type="button" />}+ data-thread-selection-safesize="sm"className="h-6 w-full translate-x-0 justify-start px-2 text-left text-[10px] text-muted-foreground/60 hover:bg-accent hover:text-muted-foreground/80"onClick={() => {diff --git a/apps/web/src/threadSelectionStore.test.ts b/apps/web/src/threadSelectionStore.test.tsnew file mode 100644index 000000000..b142c5c7d--- /dev/null+++ b/apps/web/src/threadSelectionStore.test.ts@@ -0,0 +1,292 @@+import { ThreadId } from "@t3tools/contracts";+import { beforeEach, describe, expect, it } from "vitest";++import { useThreadSelectionStore } from "./threadSelectionStore";++const THREAD_A = ThreadId.makeUnsafe("thread-a");+const THREAD_B = ThreadId.makeUnsafe("thread-b");+const THREAD_C = ThreadId.makeUnsafe("thread-c");+const THREAD_D = ThreadId.makeUnsafe("thread-d");+const THREAD_E = ThreadId.makeUnsafe("thread-e");++const ORDERED = [THREAD_A, THREAD_B, THREAD_C, THREAD_D, THREAD_E] as const;++describe("threadSelectionStore", () => {+ beforeEach(() => {+ useThreadSelectionStore.getState().clearSelection();+ });++ describe("toggleThread", () => {+ it("adds a thread to empty selection", () => {+ useThreadSelectionStore.getState().toggleThread(THREAD_A);++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.has(THREAD_A)).toBe(true);+ expect(state.selectedThreadIds.size).toBe(1);+ expect(state.anchorThreadId).toBe(THREAD_A);+ });++ it("removes a thread that is already selected", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A);+ store.toggleThread(THREAD_A);++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.has(THREAD_A)).toBe(false);+ expect(state.selectedThreadIds.size).toBe(0);+ });++ it("preserves existing selections when toggling a new thread", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A);+ store.toggleThread(THREAD_B);++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.has(THREAD_A)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_B)).toBe(true);+ expect(state.selectedThreadIds.size).toBe(2);+ });++ it("sets anchor to the newly added thread", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A);+ store.toggleThread(THREAD_B);++ expect(useThreadSelectionStore.getState().anchorThreadId).toBe(THREAD_B);+ });++ it("preserves anchor when deselecting a non-anchor thread", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A);+ store.toggleThread(THREAD_B);+ store.toggleThread(THREAD_A); // deselect A, anchor should stay B++ expect(useThreadSelectionStore.getState().anchorThreadId).toBe(THREAD_B);+ });+ });++ describe("setAnchor", () => {+ it("sets anchor without adding to selection", () => {+ useThreadSelectionStore.getState().setAnchor(THREAD_B);++ const state = useThreadSelectionStore.getState();+ expect(state.anchorThreadId).toBe(THREAD_B);+ expect(state.selectedThreadIds.size).toBe(0);+ });++ it("enables range select from a plain-click anchor", () => {+ const store = useThreadSelectionStore.getState();+ store.setAnchor(THREAD_B); // simulate plain-click navigate to B+ store.rangeSelectTo(THREAD_D, ORDERED); // shift-click D++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.has(THREAD_B)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_C)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_D)).toBe(true);+ expect(state.selectedThreadIds.size).toBe(3);+ });++ it("is a no-op when anchor is already set to the same thread", () => {+ const store = useThreadSelectionStore.getState();+ store.setAnchor(THREAD_B);+ const stateBefore = useThreadSelectionStore.getState();+ store.setAnchor(THREAD_B);+ const stateAfter = useThreadSelectionStore.getState();++ // Should be referentially the same (no unnecessary re-render)+ expect(stateAfter).toBe(stateBefore);+ });++ it("survives clearSelection followed by setAnchor", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A);+ store.toggleThread(THREAD_B);+ store.clearSelection();+ store.setAnchor(THREAD_C);++ const state = useThreadSelectionStore.getState();+ expect(state.anchorThreadId).toBe(THREAD_C);+ expect(state.selectedThreadIds.size).toBe(0);+ });+ });++ describe("rangeSelectTo", () => {+ it("selects a single thread when no anchor exists", () => {+ useThreadSelectionStore.getState().rangeSelectTo(THREAD_C, ORDERED);++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.has(THREAD_C)).toBe(true);+ expect(state.selectedThreadIds.size).toBe(1);+ expect(state.anchorThreadId).toBe(THREAD_C);+ });++ it("selects range from anchor to target (forward)", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_B); // sets anchor to B+ store.rangeSelectTo(THREAD_D, ORDERED);++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.has(THREAD_B)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_C)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_D)).toBe(true);+ expect(state.selectedThreadIds.size).toBe(3);+ });++ it("selects range from anchor to target (backward)", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_D); // sets anchor to D+ store.rangeSelectTo(THREAD_B, ORDERED);++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.has(THREAD_B)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_C)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_D)).toBe(true);+ expect(state.selectedThreadIds.size).toBe(3);+ });++ it("keeps anchor stable across multiple range selects", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_B); // anchor = B+ store.rangeSelectTo(THREAD_D, ORDERED); // selects B-D+ store.rangeSelectTo(THREAD_E, ORDERED); // extends B-E (anchor stays B)++ const state = useThreadSelectionStore.getState();+ expect(state.anchorThreadId).toBe(THREAD_B);+ expect(state.selectedThreadIds.has(THREAD_B)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_C)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_D)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_E)).toBe(true);+ });++ it("falls back to toggle when anchor is not in the ordered list", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A); // anchor = A+ // Range-select with a list that does NOT contain the anchor+ store.rangeSelectTo(THREAD_C, [THREAD_B, THREAD_C, THREAD_D]);++ const state = useThreadSelectionStore.getState();+ // Should have added C and reset anchor to C+ expect(state.selectedThreadIds.has(THREAD_C)).toBe(true);+ expect(state.anchorThreadId).toBe(THREAD_C);+ });++ it("falls back to toggle when target is not in the ordered list", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_B); // anchor = B+ const unknownThread = ThreadId.makeUnsafe("thread-unknown");+ store.rangeSelectTo(unknownThread, ORDERED);++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.has(unknownThread)).toBe(true);+ expect(state.anchorThreadId).toBe(unknownThread);+ });++ it("selects the single thread when anchor equals target", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_C); // anchor = C+ store.rangeSelectTo(THREAD_C, ORDERED); // range from C to C++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.has(THREAD_C)).toBe(true);+ expect(state.selectedThreadIds.size).toBe(1);+ });++ it("preserves previously selected threads outside the range", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A); // select A, anchor = A+ store.toggleThread(THREAD_B); // select B, anchor = B++ // Now shift-select from B (anchor) to D — should add B, C, D but keep A+ store.rangeSelectTo(THREAD_D, ORDERED);++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.has(THREAD_A)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_B)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_C)).toBe(true);+ expect(state.selectedThreadIds.has(THREAD_D)).toBe(true);+ expect(state.selectedThreadIds.size).toBe(4);+ });+ });++ describe("clearSelection", () => {+ it("clears all selected threads and anchor", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A);+ store.toggleThread(THREAD_B);+ store.clearSelection();++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.size).toBe(0);+ expect(state.anchorThreadId).toBeNull();+ });++ it("is a no-op when already empty", () => {+ const stateBefore = useThreadSelectionStore.getState();+ stateBefore.clearSelection();+ const stateAfter = useThreadSelectionStore.getState();++ // Should be referentially the same (no unnecessary re-render)+ expect(stateAfter.selectedThreadIds).toBe(stateBefore.selectedThreadIds);+ });+ });++ describe("removeFromSelection", () => {+ it("removes specified threads from selection", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A);+ store.toggleThread(THREAD_B);+ store.toggleThread(THREAD_C);+ store.removeFromSelection([THREAD_A, THREAD_C]);++ const state = useThreadSelectionStore.getState();+ expect(state.selectedThreadIds.has(THREAD_B)).toBe(true);+ expect(state.selectedThreadIds.size).toBe(1);+ });++ it("clears anchor when the anchor thread is removed", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A);+ store.toggleThread(THREAD_B); // anchor = B+ store.removeFromSelection([THREAD_B]);++ expect(useThreadSelectionStore.getState().anchorThreadId).toBeNull();+ });++ it("preserves anchor when the anchor thread is not removed", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A);+ store.toggleThread(THREAD_B); // anchor = B+ store.removeFromSelection([THREAD_A]);++ expect(useThreadSelectionStore.getState().anchorThreadId).toBe(THREAD_B);+ });++ it("is a no-op when none of the specified threads are selected", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A);+ const stateBefore = useThreadSelectionStore.getState();+ store.removeFromSelection([THREAD_B, THREAD_C]);+ const stateAfter = useThreadSelectionStore.getState();++ expect(stateAfter.selectedThreadIds).toBe(stateBefore.selectedThreadIds);+ });+ });++ describe("hasSelection", () => {+ it("returns false when nothing is selected", () => {+ expect(useThreadSelectionStore.getState().hasSelection()).toBe(false);+ });++ it("returns true when threads are selected", () => {+ useThreadSelectionStore.getState().toggleThread(THREAD_A);+ expect(useThreadSelectionStore.getState().hasSelection()).toBe(true);+ });++ it("returns false after clearing selection", () => {+ const store = useThreadSelectionStore.getState();+ store.toggleThread(THREAD_A);+ store.clearSelection();+ expect(useThreadSelectionStore.getState().hasSelection()).toBe(false);+ });+ });+});diff --git a/apps/web/src/threadSelectionStore.ts b/apps/web/src/threadSelectionStore.tsnew file mode 100644index 000000000..8360bc5c6--- /dev/null+++ b/apps/web/src/threadSelectionStore.ts@@ -0,0 +1,124 @@+/**+ * Zustand store for sidebar thread multi-selection state.+ *+ * Supports Cmd/Ctrl+Click (toggle individual), Shift+Click (range select),+ * and bulk actions on the selected set.+ */++import type { ThreadId } from "@t3tools/contracts";+import { create } from "zustand";++export interface ThreadSelectionState {+ /** Currently selected thread IDs. */+ selectedThreadIds: ReadonlySet<ThreadId>;+ /** The thread ID that anchors shift-click range selection. */+ anchorThreadId: ThreadId | null;+}++interface ThreadSelectionStore extends ThreadSelectionState {+ /** Toggle a single thread in the selection (Cmd/Ctrl+Click). */+ toggleThread: (threadId: ThreadId) => void;+ /**+ * Select a range of threads (Shift+Click).+ * Requires the ordered list of thread IDs within the same project+ * so the store can compute which threads fall between anchor and target.+ */+ rangeSelectTo: (threadId: ThreadId, orderedThreadIds: readonly ThreadId[]) => void;+ /** Clear all selection state. */+ clearSelection: () => void;+ /** Remove specific thread IDs from the selection (e.g. after deletion). */+ removeFromSelection: (threadIds: readonly ThreadId[]) => void;+ /** Set the anchor thread without adding it to the selection (e.g. on plain-click navigate). */+ setAnchor: (threadId: ThreadId) => void;+ /** Check if any threads are selected. */+ hasSelection: () => boolean;+}++const EMPTY_SET = new Set<ThreadId>();++export const useThreadSelectionStore = create<ThreadSelectionStore>((set, get) => ({+ selectedThreadIds: EMPTY_SET,+ anchorThreadId: null,++ toggleThread: (threadId) => {+ set((state) => {+ const next = new Set(state.selectedThreadIds);+ if (next.has(threadId)) {+ next.delete(threadId);+ } else {+ next.add(threadId);+ }+ return {+ selectedThreadIds: next,+ anchorThreadId: next.has(threadId) ? threadId : state.anchorThreadId,+ };+ });+ },++ rangeSelectTo: (threadId, orderedThreadIds) => {+ set((state) => {+ const anchor = state.anchorThreadId;+ if (anchor === null) {+ // No anchor yet — treat as a single toggle+ const next = new Set(state.selectedThreadIds);+ next.add(threadId);+ return { selectedThreadIds: next, anchorThreadId: threadId };+ }++ const anchorIndex = orderedThreadIds.indexOf(anchor);+ const targetIndex = orderedThreadIds.indexOf(threadId);+ if (anchorIndex === -1 || targetIndex === -1) {+ // Anchor or target not in this list (different project?) — fallback to toggle+ const next = new Set(state.selectedThreadIds);+ next.add(threadId);+ return { selectedThreadIds: next, anchorThreadId: threadId };+ }++ const start = Math.min(anchorIndex, targetIndex);+ const end = Math.max(anchorIndex, targetIndex);+ const next = new Set(state.selectedThreadIds);+ for (let i = start; i <= end; i++) {+ const id = orderedThreadIds[i];+ if (id !== undefined) {+ next.add(id);+ }+ }+ // Keep anchor stable so subsequent shift-clicks extend from the same point+ return { selectedThreadIds: next, anchorThreadId: anchor };+ });+ },++ clearSelection: () => {+ const state = get();+ if (state.selectedThreadIds.size === 0 && state.anchorThreadId === null) return;+ set({ selectedThreadIds: EMPTY_SET, anchorThreadId: null });+ },++ setAnchor: (threadId) => {+ if (get().anchorThreadId === threadId) return;+ set({ anchorThreadId: threadId });+ },++ removeFromSelection: (threadIds) => {+ set((state) => {+ const toRemove = new Set(threadIds);+ let changed = false;+ const next = new Set<ThreadId>();+ for (const id of state.selectedThreadIds) {+ if (toRemove.has(id)) {+ changed = true;+ } else {+ next.add(id);+ }+ }+ if (!changed) return state;+ const newAnchor =+ state.anchorThreadId !== null && toRemove.has(state.anchorThreadId)+ ? null+ : state.anchorThreadId;+ return { selectedThreadIds: next, anchorThreadId: newAnchor };+ });+ },++ hasSelection: () => get().selectedThreadIds.size > 0,+}));