@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/sessrumnir/src/renderer/src/utils/planning-prompt.test.ts

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict'
+import { sessionPreview, stripInjectedPreamble } from '../../../shared/session-preview'
+import { buildPlanningPrompt } from './planning-prompt'
+
+const prompt = buildPlanningPrompt('Delete unused files')
+
+assert.match(prompt, /read-only planning mode/i)
+assert.match(prompt, /inspect/i)
+assert.match(prompt, /do not edit files/i)
+assert.match(prompt, /step-by-step plan/i)
+assert.match(prompt, /Delete unused files/)
+
+// The preamble is stored verbatim as the session's first user message, so the
+// builder must stay strippable: if its opening line or request sentinel drifts,
+// every planning session's row title silently reverts to the boilerplate.
+assert.equal(stripInjectedPreamble(prompt), 'Delete unused files')
+
+const multiLineRequest = 'Fix the token refresh.\n\nIt drops the retry on 401.'
+assert.equal(stripInjectedPreamble(buildPlanningPrompt(multiLineRequest)), multiLineRequest)
+
+assert.equal(
+  sessionPreview(stripInjectedPreamble(buildPlanningPrompt('Wire up the token refresh retry'))),
+  'Wire up the token refresh retry'
+)
+
+// The regression this pairing prevents: unstripped, every planning session
+// previews as the same ~410 characters of preamble.
+assert.notEqual(
+  sessionPreview(stripInjectedPreamble(buildPlanningPrompt('Refactor auth'))),
+  sessionPreview(stripInjectedPreamble(buildPlanningPrompt('Write unit tests')))
+)

package/apps/sessrumnir/src/renderer/src/utils/planning-prompt.ts

@@ -0,0 +1,27 @@
+import {
+  PLANNING_PREAMBLE_OPENING,
+  PLANNING_PREAMBLE_SENTINEL,
+} from '../../../shared/session-preview'
+
+/**
+ * The preamble is stored verbatim as the session's first user message, so the
+ * sentinels are shared with `stripInjectedPreamble` — which uses them to recover
+ * the request for a session-list preview.
+ */
+export function buildPlanningPrompt(userPrompt: string): string {
+  return [
+    PLANNING_PREAMBLE_OPENING,
+    '',
+    'Use available read/search/list tools to inspect the workspace and build context, but do not edit files, create files, delete files, run shell commands, install packages, commit, or push.',
+    '',
+    'Return a step-by-step plan before any implementation. Include:',
+    '- Relevant context you found',
+    '- Files or areas likely involved',
+    '- Proposed changes',
+    '- Risks or assumptions',
+    '- Verification steps',
+    '',
+    PLANNING_PREAMBLE_SENTINEL,
+    userPrompt,
+  ].join('\n')
+}

package/apps/sessrumnir/src/renderer/src/utils/preview-load-error.test.ts

@@ -0,0 +1,15 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { toPreviewLoadError } from './preview-load-error'
+
+test('keeps an Error instance message verbatim', () => {
+  assert.deepEqual(toPreviewLoadError(new Error('disk full'), 'readFailed'), {
+    kind: 'message',
+    text: 'disk full',
+  })
+})
+
+test('falls back to the generic kind for a non-Error value', () => {
+  assert.deepEqual(toPreviewLoadError('string failure', 'readFailed'), { kind: 'readFailed' })
+  assert.deepEqual(toPreviewLoadError(undefined, 'saveFailed'), { kind: 'saveFailed' })
+})

package/apps/sessrumnir/src/renderer/src/utils/preview-load-error.ts

@@ -0,0 +1,22 @@
+/**
+ * Data shape for a file/image preview load or save failure. Keeping the
+ * outcome as data (instead of a translated string built inside the effect)
+ * lets the JSX translate it at render time, so the effect that produced it
+ * never needs the `t` function in its dependency array — a language change
+ * cannot re-run the load and discard unsaved edits or refetch the file.
+ */
+export type PreviewLoadError<GenericKind extends string> =
+  | { kind: 'message'; text: string }
+  | { kind: GenericKind }
+
+/**
+ * Maps a caught value to preview-error data: an `Error` keeps its own
+ * message verbatim, anything else falls back to the given generic failure
+ * kind (translated by the caller at render time).
+ */
+export function toPreviewLoadError<GenericKind extends string>(
+  err: unknown,
+  genericKind: GenericKind
+): PreviewLoadError<GenericKind> {
+  return err instanceof Error ? { kind: 'message', text: err.message } : { kind: genericKind }
+}

package/apps/sessrumnir/src/renderer/src/utils/process-status-label.test.ts

@@ -0,0 +1,13 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { t } from '../../../shared/i18n'
+import type { PiProcessStatus } from '../../../shared/ipc-contracts'
+import { processStatusLabel } from './process-status-label'
+
+test('labels every agent process status', () => {
+  const statuses: PiProcessStatus[] = ['running', 'starting', 'error', 'stopped']
+  assert.deepEqual(
+    statuses.map((status) => processStatusLabel(status, t)),
+    ['running', 'starting', 'error', 'stopped']
+  )
+})

package/apps/sessrumnir/src/renderer/src/utils/process-status-label.ts

@@ -0,0 +1,19 @@
+import type { Translate } from '../../../shared/i18n'
+import type { PiProcessStatus } from '../../../shared/ipc-contracts'
+
+/**
+ * The label for an agent process status, shared by every surface that shows
+ * one. The translator parameter is named `t` so `i18next-cli` finds the keys.
+ */
+export function processStatusLabel(status: PiProcessStatus, t: Translate): string {
+  switch (status) {
+    case 'running':
+      return t('status.processStatus.running')
+    case 'starting':
+      return t('status.processStatus.starting')
+    case 'error':
+      return t('status.processStatus.error')
+    case 'stopped':
+      return t('status.processStatus.stopped')
+  }
+}

package/apps/sessrumnir/src/renderer/src/utils/quick-switcher.test.ts

@@ -0,0 +1,68 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { filterSessions, filterWorkspaces, matchesTokens, MAX_SESSION_RESULTS } from './quick-switcher'
+import type { SessionListItem, Workspace } from '../../../shared/ipc-contracts'
+
+function session(overrides: Partial<SessionListItem>): SessionListItem {
+  return {
+    path: '/sessions/s.jsonl',
+    name: null,
+    preview: null,
+    sessionId: 's-1',
+    lastModified: 0,
+    messageCount: 1,
+    projectPath: '/projects/app',
+    projectName: 'app',
+    ...overrides,
+  }
+}
+
+function workspace(name: string, path: string): Workspace {
+  return { id: `ws-${name}`, name, path, createdAt: 0, lastActiveAt: 0, color: '#000' }
+}
+
+test('matchesTokens requires every token across the joined fields', () => {
+  assert.equal(matchesTokens('pi gui', ['pi-desktop-gui', null]), true)
+  assert.equal(matchesTokens('pi gui', ['pi-desktop', 'gui notes']), true)
+  assert.equal(matchesTokens('pi missing', ['pi-desktop-gui']), false)
+  assert.equal(matchesTokens('', ['anything']), true)
+  assert.equal(matchesTokens('   ', ['anything']), true)
+})
+
+test('filterSessions matches name, preview, and project name', () => {
+  const sessions = [
+    session({ sessionId: 'a', name: 'Fix auth bug' }),
+    session({ sessionId: 'b', preview: 'refactor the auth flow' }),
+    session({ sessionId: 'c', projectName: 'auth-service' }),
+    session({ sessionId: 'd', name: 'Unrelated' }),
+  ]
+  assert.deepEqual(
+    filterSessions(sessions, 'auth').map((s) => s.sessionId),
+    ['a', 'b', 'c'],
+  )
+})
+
+test('filterSessions preserves order and caps results', () => {
+  const sessions = Array.from({ length: MAX_SESSION_RESULTS + 5 }, (_, i) =>
+    session({ sessionId: `s-${i}`, name: `match ${i}` }),
+  )
+  const filtered = filterSessions(sessions, 'match')
+  assert.equal(filtered.length, MAX_SESSION_RESULTS)
+  assert.equal(filtered[0].sessionId, 's-0')
+})
+
+test('filterWorkspaces matches by name or path tokens', () => {
+  const workspaces = [
+    workspace('pi-desktop-gui', '/mnt/projects/pi-desktop-gui'),
+    workspace('notes', '/home/user/notes'),
+  ]
+  assert.deepEqual(
+    filterWorkspaces(workspaces, 'desktop').map((w) => w.name),
+    ['pi-desktop-gui'],
+  )
+  assert.deepEqual(
+    filterWorkspaces(workspaces, 'home user').map((w) => w.name),
+    ['notes'],
+  )
+  assert.equal(filterWorkspaces(workspaces, '').length, 2)
+})

package/apps/sessrumnir/src/renderer/src/utils/quick-switcher.ts

@@ -0,0 +1,52 @@
+import type { FileSearchResult, SessionListItem, Workspace } from '../../../shared/ipc-contracts'
+import { normalizeModelSearchText } from './model-search'
+
+/**
+ * Pure filters for the Ctrl/Cmd+K quick switcher's Workspaces / Sessions /
+ * Files sections. Token-AND matching with `_-./:` treated as spaces (the
+ * model-picker convention), so "pi gui" matches "pi-desktop-gui".
+ */
+
+export const MAX_SESSION_RESULTS = 8
+export const MAX_FILE_RESULTS = 8
+
+export interface SwitcherFileItem {
+  kind: 'file'
+  result: FileSearchResult
+}
+
+export interface SwitcherSessionItem {
+  kind: 'session'
+  session: SessionListItem
+}
+
+export interface SwitcherWorkspaceItem {
+  kind: 'workspace'
+  workspace: Workspace
+}
+
+export type SwitcherItem = SwitcherFileItem | SwitcherSessionItem | SwitcherWorkspaceItem
+
+/** Every query token must appear somewhere across the given fields. */
+export function matchesTokens(query: string, fields: Array<string | null | undefined>): boolean {
+  const tokens = normalizeModelSearchText(query).split(' ').filter(Boolean)
+  if (tokens.length === 0) return true
+  const haystack = normalizeModelSearchText(fields.filter(Boolean).join(' '))
+  return tokens.every((token) => haystack.includes(token))
+}
+
+/** Sessions matching the query; input order (last-modified desc) is kept. */
+export function filterSessions(
+  sessions: SessionListItem[],
+  query: string,
+  limit = MAX_SESSION_RESULTS,
+): SessionListItem[] {
+  return sessions
+    .filter((s) => matchesTokens(query, [s.name, s.preview, s.projectName]))
+    .slice(0, limit)
+}
+
+/** Workspaces matching the query by name or path. */
+export function filterWorkspaces(workspaces: Workspace[], query: string): Workspace[] {
+  return workspaces.filter((ws) => matchesTokens(query, [ws.name, ws.path]))
+}

package/apps/sessrumnir/src/renderer/src/utils/rank-file-results.test.ts

@@ -0,0 +1,46 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { rankFileResults } from './rank-file-results'
+import type { FileSearchResult } from '../../../shared/ipc-contracts'
+
+function result(name: string, relativePath: string): FileSearchResult {
+  return { path: `/ws/${relativePath}`, relativePath, name, matchType: 'filename' }
+}
+
+test('exact basename beats prefix beats substring beats other', () => {
+  const ranked = rankFileResults(
+    [
+      result('main-store.ts', 'src/main-store.ts'),
+      result('store', 'src/store'),
+      result('store.ts', 'src/store.ts'),
+      result('index.ts', 'src/index.ts'),
+    ],
+    'store',
+  )
+  assert.deepEqual(
+    ranked.map((r) => r.name),
+    ['store', 'store.ts', 'main-store.ts', 'index.ts'],
+  )
+})
+
+test('ties break by shorter path then alphabetically', () => {
+  const ranked = rankFileResults(
+    [
+      result('a.ts', 'deep/nested/dir/a.ts'),
+      result('a.ts', 'src/a.ts'),
+      result('a.ts', 'lib/a.ts'),
+    ],
+    'a.ts',
+  )
+  assert.deepEqual(
+    ranked.map((r) => r.relativePath),
+    ['lib/a.ts', 'src/a.ts', 'deep/nested/dir/a.ts'],
+  )
+})
+
+test('does not mutate the input array', () => {
+  const input = [result('b.ts', 'b.ts'), result('a.ts', 'a.ts')]
+  const snapshot = [...input]
+  rankFileResults(input, 'a.ts')
+  assert.deepEqual(input, snapshot)
+})

package/apps/sessrumnir/src/renderer/src/utils/rank-file-results.ts

@@ -0,0 +1,23 @@
+import type { FileSearchResult } from '../../../shared/ipc-contracts'
+
+// Rank file-search hits: exact basename match first, then basename prefix,
+// then basename substring; ties broken by shorter path (closer to the
+// workspace root), then alphabetically. The backend returns matches in
+// filesystem-walk order, which otherwise buries good hits.
+export function rankFileResults(results: FileSearchResult[], query: string): FileSearchResult[] {
+  const q = query.toLowerCase()
+  const score = (r: FileSearchResult): number => {
+    const name = r.name.toLowerCase()
+    if (name === q) return 0
+    if (name.startsWith(q)) return 1
+    if (name.includes(q)) return 2
+    return 3
+  }
+  return [...results].sort((a, b) => {
+    const byScore = score(a) - score(b)
+    if (byScore !== 0) return byScore
+    const byLen = a.relativePath.length - b.relativePath.length
+    if (byLen !== 0) return byLen
+    return a.relativePath.localeCompare(b.relativePath)
+  })
+}

package/apps/sessrumnir/src/renderer/src/utils/relative-time.tsx

@@ -0,0 +1,25 @@
+import { createContext, useContext } from 'react'
+import { useTranslation } from 'react-i18next'
+import { formatRelativeTime } from './format-relative-time'
+
+export { formatRelativeTime }
+
+/**
+ * A single "now" value, refreshed on an interval by the chat panel, so all
+ * relative-time labels tick together without each one owning a timer.
+ */
+export const NowContext = createContext<number>(Date.now())
+
+/**
+ * Renders a relative-time label that re-renders on each tick of `NowContext`.
+ * Kept as a tiny leaf so the surrounding (heavier) message bubble does not
+ * re-render every 30s — only these labels do.
+ */
+export function RelativeTime({ timestamp }: { timestamp: number }): React.JSX.Element {
+  // formatRelativeTime reads the interface language from the shared i18n
+  // instance directly (not via a prop), so this hook call is the only thing
+  // that makes the label re-render when the language changes.
+  useTranslation()
+  const now = useContext(NowContext)
+  return <span>{formatRelativeTime(timestamp, now)}</span>
+}

package/apps/sessrumnir/src/renderer/src/utils/session-title.test.ts

@@ -0,0 +1,98 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { findSessionPreview, getSessionTitle } from './session-title'
+
+test('prefers an explicit session name', () => {
+  assert.equal(getSessionTitle('My session', '2026-07-04T13-58-32-590Z_019f2d6c'), 'My session')
+  assert.equal(getSessionTitle('  Trimmed  ', 'x'), 'Trimmed')
+})
+
+test('formats a Pi timestamp id with a distinguishable time', () => {
+  // Regression: same-day sessions used to collapse to "2026-07-04T1".
+  assert.equal(
+    getSessionTitle(null, '2026-07-04T13-34-18-375Z_019f2d56-4d07-7856-b0e0-df198d5d34ef'),
+    '2026-07-04 13:34:18'
+  )
+  assert.equal(
+    getSessionTitle(null, '2026-07-04T13-58-32-590Z_019f2d6c-7d8e-7e90-8c65-fa9a3f38fc32'),
+    '2026-07-04 13:58:32'
+  )
+})
+
+test('two same-day sessions get distinct titles', () => {
+  const a = getSessionTitle(null, '2026-07-04T13-34-18-375Z_019f2d56')
+  const b = getSessionTitle(null, '2026-07-04T13-58-32-590Z_019f2d6c')
+  assert.notEqual(a, b)
+})
+
+test('falls back to a short id for a bare UUID', () => {
+  assert.equal(getSessionTitle(null, '019f2d6c-7d8e-7e90-8c65-fa9a3f38fc32'), '019f2d6c-7d8')
+})
+
+test('falls back to a short id when name is empty/whitespace', () => {
+  assert.equal(getSessionTitle('', '019f2d6c-7d8e'), '019f2d6c-7d8')
+  assert.equal(getSessionTitle('   ', '019f2d6c-7d8e'), '019f2d6c-7d8')
+})
+
+test('prefers an explicit name over a message preview', () => {
+  assert.equal(
+    getSessionTitle('debug token refresh', '2026-07-04T13-34-18-375Z_019f2d56', 'Refactor auth'),
+    'debug token refresh'
+  )
+})
+
+test('falls back to a message preview when the session is unnamed', () => {
+  assert.equal(
+    getSessionTitle(null, '2026-07-04T13-34-18-375Z_019f2d56', 'Refactor auth module login'),
+    'Refactor auth module login'
+  )
+})
+
+test('falls back to a message preview when the name was cleared to whitespace', () => {
+  assert.equal(getSessionTitle('   ', '019f2d6c-7d8e', 'Write unit tests'), 'Write unit tests')
+})
+
+test('trims a message preview', () => {
+  assert.equal(getSessionTitle(null, 'x', '  Fix token refresh  '), 'Fix token refresh')
+})
+
+test('falls back to the timestamp when neither a name nor a preview exists', () => {
+  // An empty-string preview must not win over the timestamp.
+  assert.equal(
+    getSessionTitle(null, '2026-07-04T13-34-18-375Z_019f2d56', null),
+    '2026-07-04 13:34:18'
+  )
+  assert.equal(
+    getSessionTitle(null, '2026-07-04T13-34-18-375Z_019f2d56', '   '),
+    '2026-07-04 13:34:18'
+  )
+})
+
+const SESSION_ROWS = [
+  { path: '/home/u/.pi/sessions/a.jsonl', preview: 'Explain this project structure' },
+  { path: '/home/u/.pi/sessions/b.jsonl', preview: null },
+]
+
+test('finds the active session preview by session file', () => {
+  assert.equal(
+    findSessionPreview(SESSION_ROWS, '/home/u/.pi/sessions/a.jsonl'),
+    'Explain this project structure'
+  )
+})
+
+test('titles the active session with its preview, matching its Recent row', () => {
+  // Regression: the Current Session panel showed the raw id while the same
+  // session's Recent row showed the first user message.
+  const preview = findSessionPreview(SESSION_ROWS, '/home/u/.pi/sessions/a.jsonl')
+  assert.equal(
+    getSessionTitle(null, '019f2d6c-7d8e-7e90-8c65-fa9a3f38fc32', preview),
+    'Explain this project structure'
+  )
+})
+
+test('has no preview for an unlisted, unknown or previewless session file', () => {
+  assert.equal(findSessionPreview(SESSION_ROWS, '/home/u/.pi/sessions/missing.jsonl'), null)
+  assert.equal(findSessionPreview(SESSION_ROWS, null), null)
+  assert.equal(findSessionPreview(SESSION_ROWS, undefined), null)
+  assert.equal(findSessionPreview(SESSION_ROWS, '/home/u/.pi/sessions/b.jsonl'), null)
+})

package/apps/sessrumnir/src/renderer/src/utils/session-title.ts

@@ -0,0 +1,58 @@
+import type { SessionListItem } from '../../../shared/ipc-contracts'
+import { pathsEqual } from '../../../shared/path-compare'
+
+type SessionPreviewSource = Pick<SessionListItem, 'path' | 'preview'>
+
+/**
+ * Human-readable title for a session.
+ *
+ * Pi names session files `<timestamp>_<uuid>.jsonl`, so a filesystem-listed
+ * session has no display name and a `sessionId` like
+ * `2026-07-04T13-58-32-590Z_019f2d6c-...`. The previous fallback of
+ * `sessionId.slice(0, 12)` was meant for short UUID prefixes; applied to a
+ * timestamp id it yields `2026-07-04T1` for *every* session created the same
+ * day (the slice stops mid-hour), making sessions indistinguishable.
+ *
+ * So: prefer an explicit name; then a preview of the session's first user
+ * message, which is what actually distinguishes two same-day sessions; then, if
+ * the id carries Pi's timestamp prefix, format it as `YYYY-MM-DD HH:MM:SS` (using
+ * the wall-clock recorded in the filename); otherwise fall back to the short id
+ * (e.g. a bare UUID).
+ */
+
+// Matches the leading "YYYY-MM-DDTHH-MM-SS" of a Pi session filename stem.
+const SESSION_TIMESTAMP_RE = /^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})/
+
+export function getSessionTitle(
+  name: string | null | undefined,
+  sessionId: string,
+  preview?: string | null
+): string {
+  if (name && name.trim()) return name.trim()
+  if (preview && preview.trim()) return preview.trim()
+
+  const m = SESSION_TIMESTAMP_RE.exec(sessionId)
+  if (m) {
+    const [, year, month, day, hour, minute, second] = m
+    return `${year}-${month}-${day} ${hour}:${minute}:${second}`
+  }
+
+  return sessionId.slice(0, 12)
+}
+
+/**
+ * Preview of the live session's first user message, read from the session list.
+ *
+ * `SessionState` carries no preview, so a panel that titles the active session
+ * from it alone falls back to the raw id while the same session's row in Recent
+ * — which does read the list — shows a readable title. Matching on the session
+ * file keeps the two labels in step.
+ */
+export function findSessionPreview(
+  sessions: readonly SessionPreviewSource[],
+  sessionFile: string | null | undefined
+): string | null {
+  if (!sessionFile) return null
+  const match = sessions.find((session) => pathsEqual(session.path, sessionFile))
+  return match?.preview ?? null
+}

package/apps/sessrumnir/src/renderer/src/utils/stale-guard.test.ts

@@ -0,0 +1,29 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { createStaleGuard } from './stale-guard'
+
+test('a single begin stays current until superseded', () => {
+  const guard = createStaleGuard()
+  const isCurrent = guard.begin()
+  assert.equal(isCurrent(), true)
+})
+
+test('an older begin goes stale the moment a newer one starts', () => {
+  const guard = createStaleGuard()
+  const first = guard.begin()
+  const second = guard.begin()
+
+  assert.equal(first(), false, 'the superseded load must not commit its result')
+  assert.equal(second(), true)
+})
+
+test('staleness is permanent — an old token never becomes current again', () => {
+  const guard = createStaleGuard()
+  const first = guard.begin()
+  guard.begin()
+  const third = guard.begin()
+
+  assert.equal(first(), false)
+  assert.equal(third(), true)
+  assert.equal(first(), false)
+})

package/apps/sessrumnir/src/renderer/src/utils/stale-guard.ts

@@ -0,0 +1,20 @@
+/**
+ * Last-write-wins guard for overlapping async loads: each begin() supersedes
+ * all earlier ones, and the returned check tells a load whether it is still
+ * the latest — a stale load must drop its result instead of committing state
+ * that would overwrite a newer response.
+ */
+export interface StaleGuard {
+  /** Start a load; returns a check that is true while this load is the latest. */
+  begin(): () => boolean
+}
+
+export function createStaleGuard(): StaleGuard {
+  let seq = 0
+  return {
+    begin() {
+      const id = ++seq
+      return () => id === seq
+    },
+  }
+}