workspace-groups-remote/src/client/tree.ts

882 lines
36 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* Derives the three-level workspace-groups tree: 分类文件夹 → 项目文件夹 →
* 会话行. Pure derivation — all inputs are snapshots; the renderer never
* scans. Session visibility rules mirror the official ui-workspace tree
* (blank rows only when current, archived excluded, subagent rows excluded).
*/
import type {
SessionListState,
SessionSearchResultItem,
SessionSummary,
} from '@deepseek-ai/dsh-api-session-controller/client'
import type { WorkspaceId, WorkspaceView } from '@deepseek-ai/dsh-api-workspace-controller/client'
// Type-only: the unified UI status snapshot. 0.1.6 把 running / pendingInteraction /
// 未读完成提示收敛为 ui-session 的 SessionStatusSnapshot;SessionSummary.completed
// 与 SessionListState.current 同时移除,当前会话改由 `mainView` 保留位推导。
import type { SessionStatus, SessionStatusSnapshot } from '@deepseek-ai/dsh-client-ui-session/client'
import type { SessionId } from '@deepseek-ai/dsh-session/types'
import { indexSubagentDescendants, type SubagentDescendantSummary } from './subagent-lineage.ts'
import { isDefaultWorkspace } from '../core/default-workspace.ts'
import { categoryAppearance, effectiveCategories, orderedWorkspaceIds, resolveCategory } from '../core/matcher.ts'
import {
absorbedWorkspaceIds,
EMPTY_FOLDERS_DOCUMENT,
effectiveFolders,
entryFor,
folderOfCwd,
rootOf,
samePath,
type FoldersDocument,
type WorkspaceFolderEntry,
} from '../core/folders.ts'
import {
TOP_LEVEL_ORDER_KEY,
UNCATEGORIZED_LABEL,
type CategoryAppearance,
type GroupsConfig,
type ManualGroups,
} from '../core/types.ts'
/** Pending interaction kinds with dedicated Workspace-row presentation. */
export type SessionPendingInteractionStatus = 'approval' | 'plan-review' | 'question'
/** Current unified UI status by Session (ui-session snapshot). */
type SessionStatuses = SessionStatusSnapshot
/**
* The Session the Conversation is currently showing.
*
* 0.1.6 removed `SessionListState.current`: selection is expressed as the
* Session retained through the `mainView` reference source (the ui-workspace
* navigation holds exactly one). Same read the official browser performs.
* @param list - sessions list snapshot.
* @returns the retained Session id, or undefined while no Session is selected.
*/
export function currentSessionId(list: SessionListState): SessionId | undefined {
return Object.values(list.byId).find(session => (session.retainedBy?.mainView ?? 0) > 0)?.id
}
/** Keep navigation presentation independent from domain-owned interaction objects. */
function visiblePendingKind(kind: string | undefined): SessionPendingInteractionStatus | undefined {
switch (kind) {
case 'approval':
case 'plan-review':
case 'question':
return kind
default:
return undefined
}
}
/** One top-level session row inside a workspace folder. */
export interface SessionNode {
id: SessionId
/** Stored display title; blank rows show the localized New Session label. */
title: string
/** The provisional blank session (renderer shows the localized New Session title). */
blank: boolean
pendingInteraction?: SessionPendingInteractionStatus
running: boolean
/** Running descendants connected through uninterrupted subagent-origin lineage. */
runningSubagentCount: number
/** Finished running while not selected and not yet opened (the green "done" reminder dot). */
completed: boolean
updatedAt: number
/** Search-hit marker (rendered with a highlighted tint in search mode). */
matched?: boolean
/** Content-match snippet from the Host search (search mode only). */
snippet?: string
}
/** One folder row inside a workspace folder (base or extra). */
export interface FolderNode {
/** Absolute folder path. */
path: string
/** Display label: last path segment, or the whole path for drive roots. */
label: string
/** The workspace's default target for new sessions (★). */
isRoot: boolean
expanded: boolean
/** The workspace's own canonical directory (folder #0); cannot be removed. */
isBase: boolean
/** Visible sessions whose recorded cwd lives inside this folder. */
sessions: readonly SessionNode[]
}
/** One workspace folder row inside a category folder. */
export interface WorkspaceGroupNode {
workspaceId: WorkspaceId
/** Canonical host directory path. */
path: string
/** Display title. */
label: string
/** Workspace creation time (epoch ms). */
createdAt: number
/** Total visible sessions in the folder (every folder included). */
sessionCount: number
expanded: boolean
/** The folder contains the selected session (active folder tint). */
containsCurrent: boolean
/** Base-owned visible session rows (empty while the folder is folded). */
sessions: readonly SessionNode[]
/**
* Folder rows, present only when the workspace carries at least one extra
* folder: root first, then stored order, base included. Absent means "this
* workspace has exactly one directory", the plain pre-folders node shape.
*/
folders?: readonly FolderNode[]
}
/** One category folder at the top of the tree. */
export interface CategoryNode {
/** Stable category key: the configured label, or the uncategorized bucket. */
key: string
/** Display label. */
label: string
expanded: boolean
/** The category contains the selected session (active folder tint). */
containsCurrent: boolean
/** Workspace folders in host order. */
workspaces: readonly WorkspaceGroupNode[]
/** Presentation (color / icon / pin) for this category, when configured. */
appearance?: CategoryAppearance
}
/** Viewing state consumed by the derivation. */
export interface GroupsTreeView {
expandedCategories: readonly string[]
expandedWorkspaces: readonly string[]
/**
* Collapsed folder rows, keyed by `folderKey(workspaceId, path)`. Folders are
* expanded by default: adding a folder must never hide the sessions that used
* to show flat under the project.
*/
collapsedFolders?: readonly string[]
}
/** Key of the uncategorized bucket (matches the config fallback label). */
export const UNCATEGORIZED_KEY = UNCATEGORIZED_LABEL
/**
* Names the "not sorted yet" bucket commonly gets. A group whose key matches one
* of these is docked to the bottom of the sidebar (above the default-workspace
* row) instead of taking a slot in the tree, so the workspaces a user has not
* classified yet never push the classified tree around.
*/
const DOCKED_CATEGORY_PATTERN = /^(?:未归类|未分类|未分组|未排序|待归类|ungrouped|uncategorized|unsorted)$/iu
/** Whether this category key names the "not yet classified" bucket. */
export function isDockedCategoryKey(key: string): boolean {
return DOCKED_CATEGORY_PATTERN.test(key.trim())
}
/** Directory display label: basename of the path (both separators accepted). */
export function workspaceLabel(cwd: string | undefined): string {
if (cwd === undefined || cwd === '') return UNCATEGORIZED_LABEL
const base = cwd.replace(/[/\\]+$/, '').split(/[/\\]/).pop()
return base !== undefined && base !== '' ? base : cwd
}
/** Ordinary sessions are visible; blank only when current; archived/subagent never. */
function sessionVisible(session: SessionSummary, current: SessionId | undefined, archived: ReadonlySet<SessionId>): boolean {
return session.origin !== 'subagent'
&& !archived.has(session.id)
&& (!session.blank || session.id === current)
}
/** Blank rows display the localized New Session label (never enters search). */
function sessionTitle(session: SessionSummary): string {
return session.blank ? 'New Session' : session.displayTitle
}
function sessionNode(
s: SessionSummary,
descendants: ReadonlyMap<SessionId, SubagentDescendantSummary>,
statuses: SessionStatuses,
): SessionNode {
// `SessionStatusSnapshot` is typed as ReadonlyMap, but the framework binds a
// plain record at runtime (client.js: `statuses[sessionId]`). Read both shapes
// so a hook backed by an object never throws "statuses.get is not a function".
const status = typeof (statuses as { get?: unknown } | undefined)?.get === 'function'
? statuses.get(s.id)
: (statuses as unknown as Record<string, SessionStatus | undefined>)[s.id]
const pending = visiblePendingKind(status?.pendingInteraction?.kind)
return {
id: s.id,
title: sessionTitle(s),
blank: s.blank,
running: status?.running ?? s.running,
runningSubagentCount: descendants.get(s.id)?.runningCount ?? 0,
completed: status?.completionUnread === true,
updatedAt: s.updatedAt,
...(pending === undefined ? {} : { pendingInteraction: pending }),
}
}
/** Visible sessions of one workspace in its stored account order. */
function workspaceSessions(
list: SessionListState,
workspace: WorkspaceView,
archived: ReadonlySet<SessionId>,
descendants: ReadonlyMap<SessionId, SubagentDescendantSummary>,
statuses: SessionStatuses,
current: SessionId | undefined,
): SessionNode[] {
const nodes: SessionNode[] = []
for (const id of workspace.sessionIds) {
const summary = list.byId[id]
if (summary === undefined) continue // account may lead the list pull; appears when the summary lands
if (!sessionVisible(summary, current, archived)) continue
nodes.push(sessionNode(summary, descendants, statuses))
}
return nodes
}
/** A workspace-backed ("member") folder resolved against the workspace list. */
export interface MemberWorkspaces {
/** Member workspace id → owning workspace id (the rows to hide). */
absorbed: ReadonlyMap<string, string>
/** Owning workspace id → member workspaces in stored folder order. */
byOwner: ReadonlyMap<string, readonly WorkspaceView[]>
}
/**
* Resolve the workspace-backed folders of every project.
*
* A member folder is a real DSH workspace whose OWN row must disappear: its
* sessions are rendered under its owner's folder row instead, so one project can
* carry local and cloud (SSH-mirrored) folders at once. Members the Host no
* longer knows are dropped from the index — the folder row survives (its path is
* still stored) but shows no sessions.
* @param workspaces - real workspaces in Host order.
* @param folders - per-workspace extra folders + members + root.
*/
export function memberWorkspaces(
workspaces: readonly WorkspaceView[],
folders: FoldersDocument = EMPTY_FOLDERS_DOCUMENT,
): MemberWorkspaces {
const byId = new Map<string, WorkspaceView>()
for (const workspace of workspaces) byId.set(workspace.workspaceId as string, workspace)
// Only an owner that still exists may hide a row: if the project itself is gone,
// its members must come back as their own rows instead of staying invisible. A
// chained member (an absorbed project that owns members of its own) is refused
// for the same reason — nesting would swallow the inner sessions.
const stored = absorbedWorkspaceIds(folders)
const absorbed = new Map<string, string>()
for (const [memberId, ownerId] of stored) {
if (!byId.has(ownerId) || stored.has(ownerId)) continue
absorbed.set(memberId, ownerId)
}
const byOwner = new Map<string, WorkspaceView[]>()
for (const [ownerId, entry] of Object.entries(folders.workspaces)) {
for (const member of entry.members ?? []) {
if (absorbed.get(member.workspaceId) !== ownerId) continue
const view = byId.get(member.workspaceId)
if (view === undefined) continue
const bucket = byOwner.get(ownerId)
if (bucket === undefined) byOwner.set(ownerId, [view])
else bucket.push(view)
}
}
return { absorbed, byOwner }
}
/** Visible sessions of a project: its own rows plus every member folder's rows. */
function sessionsWithMembers(
list: SessionListState,
workspace: WorkspaceView,
members: readonly WorkspaceView[],
archived: ReadonlySet<SessionId>,
descendants: ReadonlyMap<SessionId, SubagentDescendantSummary>,
statuses: SessionStatuses,
current: SessionId | undefined,
): SessionNode[] {
if (members.length === 0) {
return workspaceSessions(list, workspace, archived, descendants, statuses, current)
}
const nodes = workspaceSessions(list, workspace, archived, descendants, statuses, current)
for (const member of members) {
nodes.push(...workspaceSessions(list, member, archived, descendants, statuses, current))
}
return nodes
}
/** Whether a session lives in this project or in one of its member folders. */
function projectHoldsSession(
workspace: WorkspaceView,
members: readonly WorkspaceView[],
sessionId: SessionId | undefined,
): boolean {
if (sessionId === undefined) return false
if (workspace.sessionIds.includes(sessionId)) return true
return members.some(member => member.sessionIds.includes(sessionId))
}
/**
* Display label of one folder: the last path segment. A drive root (`C:\`) or
* the POSIX root has no segment, so the whole path is the honest label.
* @param path - absolute folder path.
*/export function folderLabel(path: string): string {
const trimmed = path.replace(/[/\\]+$/u, '')
if (trimmed === '' || /^[A-Za-z]:$/u.test(trimmed)) return path
const base = trimmed.split(/[/\\]/u).pop()
return base !== undefined && base !== '' ? base : path
}
/** Stable identity of one folder row (same path may live under two workspaces). */
export function folderKey(workspaceId: WorkspaceId, path: string): string {
return `${workspaceId}\u0000${path}`
}
/**
* Display labels for member folders.
*
* A cloud member's directory is a locally generated mirror id (`wabc123`), which
* says nothing to the user: its REMOTE path or title is the honest label. Local
* members keep the last path segment, like every other folder.
* @param folders - per-workspace folders + members.
*/
function memberFolderLabels(entry: WorkspaceFolderEntry | undefined): Map<string, string> {
const labels = new Map<string, string>()
for (const member of entry?.members ?? []) {
const label = member.kind === 'remote'
? (member.title ?? folderLabel(member.remotePath ?? member.path))
: folderLabel(member.path)
if (label !== '') labels.set(member.path, label)
}
return labels
}
/**
* Split a workspace's visible sessions between its base directory and its extra
* folders. Sessions keep the order they already had inside their owner, and a
* workspace with no extra folder returns its sessions untouched — the pre-
* folders node shape (no `folders` key at all).
* @param workspaceId - owning workspace.
* @param workspacePath - canonical directory (folder #0).
* @param sessions - every visible session of the workspace, in host order.
* @param list - sessions list snapshot (records each session's cwd).
* @param entry - saved extra folders + root for this workspace.
* @param collapsedFolders - collapsed folder-row keys. Undefined means "nothing
* is collapsed", which is both the default view and what search uses so every
* hit is visible without another click.
*/
function applyFolders(
workspaceId: WorkspaceId,
workspacePath: string,
workspaceTitle: string,
sessions: readonly SessionNode[],
list: SessionListState,
entry: WorkspaceFolderEntry | undefined,
collapsedFolders: ReadonlySet<string> | undefined,
): { sessions: readonly SessionNode[]; folders?: readonly FolderNode[] } {
const labels = memberFolderLabels(entry)
// The base row shows the project's confirmed display title (custom name or
// remote directory name) instead of the local mirror basename. The path
// remains the directory identity for file access; only the LABEL changes.
const title = workspaceTitle.trim()
if (title !== '') labels.set(workspacePath, title)
const extras = effectiveFolders(workspacePath, entry).slice(1)
if (extras.length === 0) return { sessions }
const root = rootOf(workspacePath, entry)
const base: SessionNode[] = []
const byFolder = new Map<string, SessionNode[]>()
for (const node of sessions) {
const owner = folderOfCwd(list.byId[node.id]?.cwd, workspacePath, entry)
if (samePath(owner, workspacePath)) {
base.push(node)
continue
}
const bucket = byFolder.get(owner)
if (bucket === undefined) byFolder.set(owner, [node])
else bucket.push(node)
}
const folderNode = (path: string, isBase: boolean): FolderNode => {
const owned = isBase ? base : (byFolder.get(path) ?? [])
return {
path,
label: labels.get(path) ?? folderLabel(path),
isRoot: samePath(path, root),
expanded: collapsedFolders === undefined || !collapsedFolders.has(folderKey(workspaceId, path)),
isBase,
// Every owned session is kept on the node so the row's count stays honest
// while the folder is collapsed; the RowGroup does the hiding.
sessions: owned,
}
}
const folders: FolderNode[] = [
folderNode(workspacePath, true),
...extras.map(path => folderNode(path, false)),
]
// Root first, then stored order: moving the root row to the front keeps the
// remaining rows (base included) in their stored order.
const rootIndex = folders.findIndex(folder => folder.isRoot)
if (rootIndex > 0) {
const [rootFolder] = folders.splice(rootIndex, 1)
if (rootFolder !== undefined) folders.unshift(rootFolder)
}
return { sessions: base, folders }
}
/**
* Derive the three-level tree.
* @param list - sessions list snapshot (`current` feeds containsCurrent).
* @param workspaces - real workspaces in stable Host order.
* @param archivedSessionIds - registry-global archive set.
* @param config - sidecar grouping config (rule categories).
* @param view - local expansion arrays.
* @param manual - runtime overlay (manual groups + overrides). A workspace's
* manual override wins over rule classification; removing it reverts to rules.
* @param statuses - unified UI status by Session (drives the running / warning
* / unread-completion row indicators); defaults to none (tests).
* @param folders - per-workspace extra folders + root. A workspace with extras
* gains folder rows and its extra-folder sessions move under them; a workspace
* without extras keeps exactly the pre-folders node shape.
* @returns category sections in render order (rule categories first, then
* manual-only ones, uncategorized last). Manual groups render even while
* empty; empty rule buckets stay hidden.
*/
export function deriveGroups(
list: SessionListState,
workspaces: readonly WorkspaceView[],
archivedSessionIds: readonly SessionId[],
config: GroupsConfig,
view: GroupsTreeView,
manual: ManualGroups,
statuses: SessionStatuses = new Map(),
folders: FoldersDocument = EMPTY_FOLDERS_DOCUMENT,
): CategoryNode[] {
const archived = new Set(archivedSessionIds)
const expandedCategories = new Set(view.expandedCategories)
const expandedWorkspaces = new Set(view.expandedWorkspaces)
const collapsedFolders = new Set(view.collapsedFolders ?? [])
const descendants = indexSubagentDescendants(list.byId)
const current = currentSessionId(list)
const members = memberWorkspaces(workspaces, folders)
// Bucket workspaces by display key. Seed with every effective category so
// manual groups render while empty. Top-level (ungrouped) workspaces are
// handled by deriveTopLevel and never land here.
const byCategory = new Map<string, WorkspaceView[]>()
for (const { key } of effectiveCategories(config, manual)) {
byCategory.set(key, [])
}
for (const workspace of workspaces) {
// The Host default workspace is pinned to its own bottom bar, never grouped.
if (isDefaultWorkspace(workspace)) continue
// Member folders render inside their owner; their own row is not a project.
if (members.absorbed.has(workspace.workspaceId as string)) continue
const key = resolveCategory(config, manual, workspace.workspaceId, workspace.path, workspace.title)
if (key === undefined) continue // top-level — rendered by deriveTopLevel
if (!byCategory.has(key)) byCategory.set(key, [])
byCategory.get(key)!.push(workspace)
}
const manualCategories = new Set(manual.categories)
const currentWorkspaceId = current === undefined
? undefined
: workspaces.find(w => !members.absorbed.has(w.workspaceId as string)
&& projectHoldsSession(w, members.byOwner.get(w.workspaceId as string) ?? [], current))?.workspaceId
const nodes: CategoryNode[] = []
// Effective categories in display order (categoryOrder applied).
for (const key of effectiveCategories(config, manual).map(e => e.key)) {
const bucket = byCategory.get(key) ?? []
// Manual groups stay visible while empty; everything else hides when empty.
if (bucket.length === 0 && !manualCategories.has(key)) continue
const expanded = expandedCategories.has(key)
const ordered = orderedWorkspaceIds(manual, key, bucket.map(w => w.workspaceId as string))
const workspaceNodes: WorkspaceGroupNode[] = []
let containsCurrent = false
for (const workspaceId of ordered) {
const workspace = bucket.find(w => w.workspaceId === workspaceId)
if (workspace === undefined) continue
const ownerMembers = members.byOwner.get(workspace.workspaceId as string) ?? []
const sessions = sessionsWithMembers(list, workspace, ownerMembers, archived, descendants, statuses, current)
const wsExpanded = expandedWorkspaces.has(workspace.workspaceId as string)
const wsContainsCurrent = workspace.workspaceId === currentWorkspaceId
const partitioned = applyFolders(
workspace.workspaceId,
workspace.path,
workspace.title,
sessions,
list,
entryFor(folders, workspace.workspaceId as string),
collapsedFolders,
)
if (wsContainsCurrent) containsCurrent = true
workspaceNodes.push({
workspaceId: workspace.workspaceId,
path: workspace.path,
label: workspace.title,
createdAt: Date.parse(workspace.createdAt),
sessionCount: sessions.length,
expanded: wsExpanded,
containsCurrent: wsContainsCurrent,
sessions: wsExpanded ? partitioned.sessions : [],
...(partitioned.folders === undefined ? {} : { folders: partitioned.folders }),
})
}
const appearance = categoryAppearance(manual, key)
nodes.push({
key,
label: key,
expanded,
containsCurrent,
workspaces: workspaceNodes,
...(appearance === undefined ? {} : { appearance }),
})
}
return nodes
}
/**
* Top-level (ungrouped) workspace rows: workspaces resolving to no category
* (no manual override and no matching rule, or a forced `null` override).
* Rendered after the group folders as plain project rows (not inside any
* folder), in manual top-level order (`workspaceOrder[TOP_LEVEL_ORDER_KEY]`),
* falling back to host registration order.
*/
export function deriveTopLevel(
list: SessionListState,
workspaces: readonly WorkspaceView[],
archivedSessionIds: readonly SessionId[],
config: GroupsConfig,
view: GroupsTreeView,
manual: ManualGroups,
statuses: SessionStatuses = new Map(),
folders: FoldersDocument = EMPTY_FOLDERS_DOCUMENT,
): WorkspaceGroupNode[] {
const archived = new Set(archivedSessionIds)
const expandedWorkspaces = new Set(view.expandedWorkspaces)
const collapsedFolders = new Set(view.collapsedFolders ?? [])
const descendants = indexSubagentDescendants(list.byId)
const current = currentSessionId(list)
const members = memberWorkspaces(workspaces, folders)
const currentWorkspaceId = current === undefined
? undefined
: workspaces.find(w => !members.absorbed.has(w.workspaceId as string)
&& projectHoldsSession(w, members.byOwner.get(w.workspaceId as string) ?? [], current))?.workspaceId
const topLevelIds = workspaces
.filter(w => !isDefaultWorkspace(w))
.filter(w => !members.absorbed.has(w.workspaceId as string))
.filter(w => resolveCategory(config, manual, w.workspaceId, w.path, w.title) === undefined)
.map(w => w.workspaceId as string)
const ordered = orderedWorkspaceIds(manual, TOP_LEVEL_ORDER_KEY, topLevelIds)
const nodes: WorkspaceGroupNode[] = []
for (const workspaceId of ordered) {
const workspace = workspaces.find(w => w.workspaceId === workspaceId)
if (workspace === undefined) continue
const ownerMembers = members.byOwner.get(workspaceId) ?? []
const sessions = sessionsWithMembers(list, workspace, ownerMembers, archived, descendants, statuses, current)
const wsExpanded = expandedWorkspaces.has(workspaceId)
const partitioned = applyFolders(
workspace.workspaceId,
workspace.path,
workspace.title,
sessions,
list,
entryFor(folders, workspaceId),
collapsedFolders,
)
nodes.push({
workspaceId: workspace.workspaceId,
path: workspace.path,
label: workspace.title,
createdAt: Date.parse(workspace.createdAt),
sessionCount: sessions.length,
expanded: wsExpanded,
containsCurrent: workspace.workspaceId === currentWorkspaceId,
sessions: wsExpanded ? partitioned.sessions : [],
...(partitioned.folders === undefined ? {} : { folders: partitioned.folders }),
})
}
return nodes
}
/**
* The Host's default workspace as a standalone node for the pinned bottom bar.
*
* The default workspace is not part of the grouping tree (it is excluded from
* `deriveGroups`, `deriveTopLevel` and the search results), yet it keeps the
* full workspace-row behaviour: expansion, session count, its sessions and its
* extra folders. This derives exactly that node, reusing the same visibility,
* folder partitioning and current-session marking as the tree.
*
* @param list - sessions list snapshot.
* @param workspaces - real workspaces in stable Host order.
* @param archivedSessionIds - registry-global archive set.
* @param view - local expansion arrays.
* @param statuses - unified UI status by Session.
* @param folders - per-workspace extra folders + root.
* @returns the default workspace node, or undefined when the Host has none.
*/
export function deriveDefaultWorkspace(
list: SessionListState,
workspaces: readonly WorkspaceView[],
archivedSessionIds: readonly SessionId[],
view: GroupsTreeView,
statuses: SessionStatuses = new Map(),
folders: FoldersDocument = EMPTY_FOLDERS_DOCUMENT,
): WorkspaceGroupNode | undefined {
const workspace = workspaces.find(w => isDefaultWorkspace(w))
if (workspace === undefined) return undefined
const archived = new Set(archivedSessionIds)
const expandedWorkspaces = new Set(view.expandedWorkspaces)
const collapsedFolders = new Set(view.collapsedFolders ?? [])
const descendants = indexSubagentDescendants(list.byId)
const current = currentSessionId(list)
const members = memberWorkspaces(workspaces, folders)
const ownerMembers = members.byOwner.get(workspace.workspaceId as string) ?? []
const sessions = sessionsWithMembers(list, workspace, ownerMembers, archived, descendants, statuses, current)
const wsExpanded = expandedWorkspaces.has(workspace.workspaceId as string)
const partitioned = applyFolders(
workspace.workspaceId,
workspace.path,
workspace.title,
sessions,
list,
entryFor(folders, workspace.workspaceId as string),
collapsedFolders,
)
return {
workspaceId: workspace.workspaceId,
path: workspace.path,
label: workspace.title,
createdAt: Date.parse(workspace.createdAt),
sessionCount: sessions.length,
expanded: wsExpanded,
containsCurrent: projectHoldsSession(workspace, ownerMembers, current),
sessions: wsExpanded ? partitioned.sessions : [],
...(partitioned.folders === undefined ? {} : { folders: partitioned.folders }),
}
}
/** Recency comparator: newest first, id as the deterministic tiebreak. */
function byRecency(a: SessionSummary, b: SessionSummary): number {
if (b.updatedAt !== a.updatedAt) return b.updatedAt - a.updatedAt
return a.id < b.id ? -1 : 1
}
/** Bounded set of matched sessions plus content snippets (feeds the search tree). */
export interface SearchMatchSet {
/** Session ids that matched (local metadata hits + Host content hits). */
matchedIds: ReadonlySet<SessionId>
/** Content-match snippets keyed by session id (Host search only). */
snippetsBySession: ReadonlyMap<SessionId, string>
hasMore: boolean
}
/**
* Compute the matched-session set: immediate title/Workspace substring matches
* from the local list, merged with ranked Host content matches. The consumer
* (SearchBody) derives the pruned three-level tree from these ids.
*/
export function deriveSearchMatches(
list: SessionListState,
workspaces: readonly WorkspaceView[],
config: GroupsConfig,
query: string,
archivedSessionIds: readonly SessionId[],
content: { items: readonly SessionSearchResultItem[]; hasMore: boolean },
limit: number,
folders: FoldersDocument = EMPTY_FOLDERS_DOCUMENT,
): SearchMatchSet {
const q = query.trim().toLowerCase()
if (q === '') return { matchedIds: new Set(), snippetsBySession: new Map(), hasMore: false }
const archived = new Set(archivedSessionIds)
const descendants = indexSubagentDescendants(list.byId)
const current = currentSessionId(list)
const members = memberWorkspaces(workspaces, folders)
// A member folder's sessions search as part of the project that shows them.
const workspaceBySession = new Map<SessionId, WorkspaceView>()
for (const workspace of workspaces) {
if (members.absorbed.has(workspace.workspaceId as string)) continue
const owner = workspace
for (const sessionId of workspace.sessionIds) {
if (!workspaceBySession.has(sessionId)) workspaceBySession.set(sessionId, owner)
}
for (const member of members.byOwner.get(workspace.workspaceId as string) ?? []) {
for (const sessionId of member.sessionIds) {
if (!workspaceBySession.has(sessionId)) workspaceBySession.set(sessionId, owner)
}
}
}
const labelOf = (summary: SessionSummary): string =>
workspaceBySession.get(summary.id)?.title ?? workspaceLabel(summary.cwd)
const local: SessionSummary[] = []
for (const id of list.ids) {
const summary = list.byId[id]
if (summary === undefined || summary.blank || !sessionVisible(summary, current, archived)) continue
if (
sessionTitle(summary).toLowerCase().includes(q)
|| labelOf(summary).toLowerCase().includes(q)
) {
local.push(summary)
}
}
local.sort(byRecency)
const ordered: SessionSummary[] = []
const included = new Set<SessionId>()
const include = (summary: SessionSummary): void => {
if (included.has(summary.id)) return
included.add(summary.id)
ordered.push(summary)
}
for (const summary of local) include(summary)
for (const item of content.items) {
const summary = list.byId[item.sessionId]
if (summary !== undefined && !summary.blank && sessionVisible(summary, current, archived)) include(summary)
}
const snippets = new Map<SessionId, string>()
for (const item of content.items) {
if (item.snippet !== undefined) snippets.set(item.sessionId, item.snippet)
}
return {
matchedIds: ordered.slice(0, limit).reduce((set, summary) => { set.add(summary.id); return set }, new Set<SessionId>()),
snippetsBySession: snippets,
hasMore: content.hasMore || ordered.length > limit,
}
}
/** Search tree: group folders plus top-level (ungrouped) matched workspaces. */
export interface SearchTree {
/** Group folders containing matched sessions, in display order. */
categories: CategoryNode[]
/** Top-level (ungrouped) workspaces holding matched sessions. */
topLevel: WorkspaceGroupNode[]
/**
* The Host default workspace's matched branch, when it has a hit. It is
* rendered in the pinned bottom bar instead of the results list, so a hit
* never makes the default workspace appear twice.
*/
defaultWorkspace?: WorkspaceGroupNode
}
/**
* Build a three-level search tree containing ONLY the branches that hold a
* matched session: 分类文件夹 → 项目文件夹 → 命中会话行. Every matched
* session carries `matched: true` so rows render with the search-hit tint.
* Classification uses the same precedence as the idle tree (manual override →
* rules), so search shows the same grouping the user sees. Matched top-level
* workspaces are returned separately (rendered as plain rows).
*
* @param list - sessions list snapshot.
* @param workspaces - real workspaces in stable Host order.
* @param config - sidecar grouping config.
* @param matchedIds - set of session ids that matched the query.
* @param archivedSessionIds - registry-global archive set.
* @param manual - runtime overlay (manual groups + overrides).
* @param snippetsBySession - optional content-match snippets keyed by session id.
* @param statuses - unified UI status by Session (drives the running / warning
* / unread-completion row indicators); defaults to none (tests).
* @param folders - per-workspace extra folders + root, so a hit inside an extra
* folder surfaces under that folder instead of flat under the project.
* @returns group folders in render order plus top-level matched workspaces,
* pruned to matched branches only.
*/
export function deriveSearchGroups(
list: SessionListState,
workspaces: readonly WorkspaceView[],
config: GroupsConfig,
matchedIds: ReadonlySet<SessionId>,
archivedSessionIds: readonly SessionId[],
manual: ManualGroups,
snippetsBySession?: ReadonlyMap<SessionId, string>,
statuses: SessionStatuses = new Map(),
folders: FoldersDocument = EMPTY_FOLDERS_DOCUMENT,
): SearchTree {
const archived = new Set(archivedSessionIds)
const descendants = indexSubagentDescendants(list.byId)
const current = currentSessionId(list)
const members = memberWorkspaces(workspaces, folders)
const byCategory = new Map<string, WorkspaceGroupNode[]>()
for (const key of effectiveCategories(config, manual).map(e => e.key)) byCategory.set(key, [])
const topLevel: WorkspaceGroupNode[] = []
let defaultWorkspace: WorkspaceGroupNode | undefined
for (const workspace of workspaces) {
// A member's own row is folded into its owner's folder row below.
if (members.absorbed.has(workspace.workspaceId as string)) continue
// Only sessions that matched the query and are visible in this folder.
const nodes: SessionNode[] = []
const sources = [workspace, ...(members.byOwner.get(workspace.workspaceId as string) ?? [])]
for (const source of sources) {
for (const id of source.sessionIds) {
const summary = list.byId[id]
if (summary === undefined || !matchedIds.has(id)) continue
if (!sessionVisible(summary, current, archived)) continue
const node = sessionNode(summary, descendants, statuses)
const snippet = snippetsBySession?.get(id)
nodes.push({
...node,
matched: true,
...(snippet === undefined ? {} : { snippet }),
})
}
}
if (nodes.length === 0) continue
const partitioned = applyFolders(
workspace.workspaceId,
workspace.path,
workspace.title,
nodes,
list,
entryFor(folders, workspace.workspaceId as string),
undefined,
)
const node: WorkspaceGroupNode = {
workspaceId: workspace.workspaceId,
path: workspace.path,
label: workspace.title,
createdAt: Date.parse(workspace.createdAt),
sessionCount: nodes.length,
expanded: true,
containsCurrent: false,
sessions: partitioned.sessions,
...(partitioned.folders === undefined ? {} : { folders: partitioned.folders }),
}
if (isDefaultWorkspace(workspace)) {
defaultWorkspace = node
continue
}
const key = resolveCategory(config, manual, workspace.workspaceId, workspace.path, workspace.title)
if (key === undefined) {
topLevel.push(node)
continue
}
if (!byCategory.has(key)) byCategory.set(key, [])
byCategory.get(key)!.push(node)
}
const categories: CategoryNode[] = []
// Same display order as the idle tree.
for (const key of effectiveCategories(config, manual).map(e => e.key)) {
const workspaceNodes = byCategory.get(key)
if (workspaceNodes === undefined || workspaceNodes.length === 0) continue
const appearance = categoryAppearance(manual, key)
categories.push({
key,
label: key,
expanded: true,
containsCurrent: false,
workspaces: workspaceNodes,
...(appearance === undefined ? {} : { appearance }),
})
}
return {
categories,
topLevel,
...(defaultWorkspace === undefined ? {} : { defaultWorkspace }),
}
}