@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/sessrumnir/src/renderer/src/components/sidebar-activity.test.ts

@@ -0,0 +1,47 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { summarizeBackgroundActivity, workspaceActivityIndicator } from './sidebar-activity'
+import type { WorkspaceActivityMap } from '../../../shared/ipc-contracts'
+
+test('workspaceActivityIndicator maps each state, skipping needs-approval', () => {
+  assert.equal(workspaceActivityIndicator(undefined), null)
+  assert.equal(workspaceActivityIndicator({ state: 'needs-approval', since: 1 }), null)
+
+  const working = workspaceActivityIndicator({ state: 'working', since: 1 })
+  assert.equal(working?.pulse, true)
+  assert.equal(working?.colorClass, 'bg-accent')
+
+  const completed = workspaceActivityIndicator({ state: 'completed', since: 1 })
+  assert.equal(completed?.pulse, false)
+  assert.equal(completed?.colorClass, 'bg-success')
+
+  const failed = workspaceActivityIndicator({ state: 'failed', since: 1 })
+  assert.equal(failed?.colorClass, 'bg-error')
+})
+
+test('summarizeBackgroundActivity ignores the active workspace', () => {
+  const map: WorkspaceActivityMap = { 'ws-active': { state: 'failed', since: 1 } }
+  assert.equal(summarizeBackgroundActivity(map, 'ws-active'), null)
+})
+
+test('summarizeBackgroundActivity prefers failed over completed over working', () => {
+  const map: WorkspaceActivityMap = {
+    'ws-1': { state: 'working', since: 1 },
+    'ws-2': { state: 'completed', since: 1 },
+    'ws-3': { state: 'failed', since: 1 },
+  }
+  const summary = summarizeBackgroundActivity(map, 'ws-active')
+  assert.equal(summary?.colorClass, 'bg-error')
+  assert.match(summary?.label ?? '', /another workspace/)
+
+  delete map['ws-3']
+  assert.equal(summarizeBackgroundActivity(map, 'ws-active')?.colorClass, 'bg-success')
+
+  delete map['ws-2']
+  assert.equal(summarizeBackgroundActivity(map, 'ws-active')?.colorClass, 'bg-accent')
+})
+
+test('summarizeBackgroundActivity yields nothing for needs-approval only', () => {
+  const map: WorkspaceActivityMap = { 'ws-1': { state: 'needs-approval', since: 1 } }
+  assert.equal(summarizeBackgroundActivity(map, 'ws-active'), null)
+})

package/apps/sessrumnir/src/renderer/src/components/sidebar-activity.ts

@@ -0,0 +1,76 @@
+import type { WorkspaceActivity, WorkspaceActivityMap } from '../../../shared/ipc-contracts'
+import { t } from '../../../shared/i18n'
+
+/**
+ * Pure helpers mapping the main-process workspace-activity map to sidebar
+ * indicators. Needs-approval deliberately yields no dot: the existing warning
+ * count badge already covers held prompts, and a second marker for the same
+ * fact would double-signal.
+ */
+
+export interface ActivityIndicator {
+  /** Semantic background class for the dot. */
+  colorClass: string
+  /** Pulse animation for in-flight work. */
+  pulse: boolean
+  /** Tooltip text. */
+  label: string
+}
+
+export function workspaceActivityIndicator(
+  activity: WorkspaceActivity | undefined,
+): ActivityIndicator | null {
+  switch (activity?.state) {
+    case 'working':
+      return { colorClass: 'bg-accent', pulse: true, label: t('activity.working') }
+    case 'completed':
+      return { colorClass: 'bg-success', pulse: false, label: t('activity.completed') }
+    case 'failed':
+      return { colorClass: 'bg-error', pulse: false, label: t('activity.failed') }
+    default:
+      return null
+  }
+}
+
+/**
+ * One aggregate indicator for the collapsed switcher header, covering every
+ * workspace EXCEPT the active one (whose state is already on screen).
+ * Priority: failed > completed > working.
+ */
+export function summarizeBackgroundActivity(
+  map: WorkspaceActivityMap,
+  activeWorkspaceId: string | null,
+): ActivityIndicator | null {
+  let best: ActivityIndicator | null = null
+  let bestRank = -1
+  const ranks = { failed: 3, completed: 2, working: 1 } as const
+
+  for (const [workspaceId, activity] of Object.entries(map)) {
+    if (workspaceId === activeWorkspaceId) continue
+    const rank = activity.state in ranks ? ranks[activity.state as keyof typeof ranks] : 0
+    if (rank > bestRank) {
+      const indicator = workspaceActivityIndicator(activity)
+      if (indicator) {
+        const label = inAnotherWorkspaceLabel(activity.state)
+        if (label) {
+          best = { ...indicator, label }
+          bestRank = rank
+        }
+      }
+    }
+  }
+  return best
+}
+
+function inAnotherWorkspaceLabel(state: WorkspaceActivity['state']): string | null {
+  switch (state) {
+    case 'working':
+      return t('activity.workingInAnotherWorkspace')
+    case 'completed':
+      return t('activity.completedInAnotherWorkspace')
+    case 'failed':
+      return t('activity.failedInAnotherWorkspace')
+    default:
+      return null
+  }
+}

package/apps/sessrumnir/src/renderer/src/components/sidebar-session-labels.test.ts

@@ -0,0 +1,73 @@
+import assert from 'node:assert/strict'
+import { getSessionEngineLabel, getSessionRowLabels, hasMixedSessionEngines } from './sidebar-session-labels'
+
+const namelessCurrentWorkspace = {
+  name: null,
+  preview: null,
+  sessionId: '2026-06-20T215802',
+  projectName: 'pi gui',
+  projectPath: '/work/pi-gui',
+}
+
+assert.deepEqual(getSessionRowLabels(namelessCurrentWorkspace), {
+  title: '2026-06-20T2',
+  subtitle: 'pi gui',
+})
+
+assert.deepEqual(
+  getSessionRowLabels({
+    ...namelessCurrentWorkspace,
+    name: 'Rename context menu',
+  }),
+  {
+    title: 'Rename context menu',
+    subtitle: 'pi gui',
+  }
+)
+
+// An unnamed session falls back to its first-message preview rather than to the
+// session id, which is what made same-day sessions indistinguishable.
+assert.deepEqual(
+  getSessionRowLabels({
+    ...namelessCurrentWorkspace,
+    preview: 'Refactor auth module login logic',
+  }),
+  {
+    title: 'Refactor auth module login logic',
+    subtitle: 'pi gui',
+  }
+)
+
+// An explicit name still outranks the preview.
+assert.deepEqual(
+  getSessionRowLabels({
+    ...namelessCurrentWorkspace,
+    name: 'debug token refresh',
+    preview: 'Refactor auth module login logic',
+  }),
+  {
+    title: 'debug token refresh',
+    subtitle: 'pi gui',
+  }
+)
+
+// The tag names the CLI that owns the session, matching the status bar wording.
+assert.equal(getSessionEngineLabel({ engine: 'pi' }), 'Pi')
+assert.equal(getSessionEngineLabel({ engine: 'omp' }), 'OMP')
+
+// A row from an older index carries no engine. It must stay untagged rather
+// than be guessed at, because guessing would open a session with the wrong CLI.
+assert.equal(getSessionEngineLabel({}), null)
+
+// With one engine installed the tag would only repeat what every row already is.
+assert.equal(hasMixedSessionEngines([]), false)
+assert.equal(hasMixedSessionEngines([{ engine: 'pi' }, { engine: 'pi' }]), false)
+assert.equal(hasMixedSessionEngines([{ engine: 'omp' }, { engine: 'omp' }]), false)
+
+// An untagged row is not a second engine, so it alone must not turn tags on.
+assert.equal(hasMixedSessionEngines([{ engine: 'omp' }, {}]), false)
+assert.equal(hasMixedSessionEngines([{}, {}]), false)
+
+// Two real engines on screen: the tag is now the only way to tell rows apart.
+assert.equal(hasMixedSessionEngines([{ engine: 'pi' }, {}, { engine: 'omp' }]), true)
+assert.equal(hasMixedSessionEngines([{ engine: 'omp' }, { engine: 'pi' }]), true)

package/apps/sessrumnir/src/renderer/src/components/sidebar-session-labels.ts

@@ -0,0 +1,47 @@
+import type { AgentEngineKind, SessionListItem } from '../../../shared/ipc-contracts'
+import { getSessionTitle } from '../utils/session-title'
+import { agentEngineLabel } from '../../../shared/agent-engine-label'
+
+type SessionRowLabelInput = Pick<
+  SessionListItem,
+  'name' | 'preview' | 'sessionId' | 'projectName' | 'projectPath'
+>
+
+type SessionEngineInput = Pick<SessionListItem, 'engine'>
+
+interface SessionRowLabels {
+  title: string
+  subtitle: string | null
+}
+
+export function getSessionRowLabels(session: SessionRowLabelInput): SessionRowLabels {
+  const subtitle = session.projectName.trim()
+
+  return {
+    title: getSessionTitle(session.name, session.sessionId, session.preview),
+    subtitle: subtitle || null,
+  }
+}
+
+/**
+ * Tag naming the engine a session belongs to, or null when the main process
+ * could not classify it. An unlabelled row is left untagged rather than being
+ * guessed into one engine — the two are not interchangeable.
+ */
+export function getSessionEngineLabel(session: SessionEngineInput): string | null {
+  return agentEngineLabel(session.engine)
+}
+
+/**
+ * True when the sessions come from more than one engine. With a single engine
+ * on screen the tag names what everything already is, so it is only noise.
+ */
+export function hasMixedSessionEngines(sessions: readonly SessionEngineInput[]): boolean {
+  let seen: AgentEngineKind | null = null
+  for (const session of sessions) {
+    if (!session.engine) continue
+    if (seen === null) seen = session.engine
+    else if (seen !== session.engine) return true
+  }
+  return false
+}