nastechai-desktop 18.1.0

package/src/lib/session-search.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest'
+
+import type { SessionInfo } from '@/types/nastech'
+
+import { sessionMatchesSearch } from './session-search'
+
+function makeSession(overrides: Partial<SessionInfo> = {}): SessionInfo {
+  return {
+    archived: false,
+    cwd: '/home/user/projects/nastech-agent',
+    ended_at: null,
+    id: '20260603_090200_abcd12',
+    input_tokens: 0,
+    is_active: false,
+    last_active: 1_000,
+    message_count: 2,
+    model: 'claude',
+    output_tokens: 0,
+    preview: 'Fix Desktop session search',
+    source: 'cli',
+    started_at: 1_000,
+    title: 'Desktop Search Feature',
+    tool_call_count: 0,
+    ...overrides
+  }
+}
+
+describe('sessionMatchesSearch', () => {
+  it('matches loaded sessions by full and partial session id', () => {
+    const session = makeSession()
+
+    expect(sessionMatchesSearch(session, '20260603_090200_abcd12')).toBe(true)
+    expect(sessionMatchesSearch(session, '090200')).toBe(true)
+    expect(sessionMatchesSearch(session, 'ABCD12')).toBe(true)
+  })
+
+  it('matches projected compression sessions by lineage root id', () => {
+    const session = makeSession({
+      _lineage_root_id: '20260602_235959_root99',
+      id: '20260603_010000_tip01'
+    })
+
+    expect(sessionMatchesSearch(session, 'root99')).toBe(true)
+    expect(sessionMatchesSearch(session, '20260602')).toBe(true)
+  })
+
+  it('preserves title, preview, and workspace matching', () => {
+    const session = makeSession()
+
+    expect(sessionMatchesSearch(session, 'desktop search')).toBe(true)
+    expect(sessionMatchesSearch(session, 'session search')).toBe(true)
+    expect(sessionMatchesSearch(session, 'nastech-agent')).toBe(true)
+  })
+
+  it('does not match unrelated queries', () => {
+    expect(sessionMatchesSearch(makeSession(), 'totally-unrelated')).toBe(false)
+  })
+})

package/src/lib/session-search.ts

@@ -0,0 +1,19 @@
+import type { SessionInfo } from '@/types/nastech'
+
+import { sessionTitle } from './chat-runtime'
+
+export function sessionMatchesSearch(session: SessionInfo, query: string): boolean {
+  const needle = query.trim().toLowerCase()
+
+  if (!needle) {
+    return true
+  }
+
+  return [
+    session.id,
+    session._lineage_root_id ?? '',
+    sessionTitle(session),
+    session.preview ?? '',
+    session.cwd ?? ''
+  ].some(value => value.toLowerCase().includes(needle))
+}

package/src/lib/session-source.ts

@@ -0,0 +1,62 @@
+const SOURCE_LABELS: Record<string, string> = {
+  api_server: 'API',
+  bluebubbles: 'iMessage',
+  cli: 'CLI',
+  codex: 'Codex',
+  desktop: 'Desktop',
+  discord: 'Discord',
+  email: 'Email',
+  gateway: 'Gateway',
+  local: 'Local',
+  matrix: 'Matrix',
+  mattermost: 'Mattermost',
+  qqbot: 'QQ',
+  signal: 'Signal',
+  slack: 'Slack',
+  sms: 'SMS',
+  telegram: 'Telegram',
+  tui: 'TUI',
+  webhook: 'Webhook',
+  weixin: 'WeChat',
+  whatsapp: 'WhatsApp',
+  yuanbao: 'Yuanbao'
+}
+
+const SOURCE_ALIASES: Record<string, string[]> = {
+  bluebubbles: ['apple messages', 'imessage'],
+  cli: ['terminal'],
+  desktop: ['app', 'gui'],
+  local: ['machine'],
+  qqbot: ['qq'],
+  telegram: ['tg'],
+  tui: ['terminal'],
+  weixin: ['wechat'],
+  whatsapp: ['wa']
+}
+
+export function normalizeSessionSource(source: null | string | undefined): string | null {
+  const id = source?.trim().toLowerCase()
+
+  return id || null
+}
+
+export function sessionSourceLabel(source: null | string | undefined): string | null {
+  const id = normalizeSessionSource(source)
+
+  if (!id) {
+    return null
+  }
+
+  return SOURCE_LABELS[id] || id.replace(/[_-]+/g, ' ').replace(/\b\w/g, char => char.toUpperCase())
+}
+
+export function sessionSourceSearchTerms(source: null | string | undefined): string[] {
+  const id = normalizeSessionSource(source)
+  const label = sessionSourceLabel(id)
+
+  if (!id) {
+    return []
+  }
+
+  return [id, label ?? '', ...(SOURCE_ALIASES[id] ?? [])].filter(Boolean)
+}

package/src/lib/speech-text.ts

@@ -0,0 +1,35 @@
+const EMOJI_RE = /(?:[\u{1F000}-\u{1FAFF}\u{2600}-\u{27BF}]|[\u{FE0F}\u{200D}]|[\u{E0020}-\u{E007F}])+/gu
+
+const FENCED_CODE_RE = /```[\s\S]*?(?:```|$)/g
+const INLINE_CODE_RE = /`([^`]+)`/g
+const MARKDOWN_LINK_RE = /\[([^\]]+)\]\(([^)]+)\)/g
+const PARAGRAPH_BREAK_RE = /[ \t]*\n{2,}[ \t]*/g
+const SOFT_BREAK_RE = /[ \t]*\n[ \t]*/g
+
+const THINKING_PREFIX_RE =
+  /^\s*(?:\([^)\n]{1,48}\)\s*)?(?:processing|thinking|reasoning|analyzing|pondering|contemplating|musing|cogitating|ruminating|deliberating|mulling|reflecting|computing|synthesizing|formulating|brainstorming)\.\.\.\s*/i
+
+const URL_RE = /\bhttps?:\/\/\S+/gi
+
+function normalizeLineBreaks(text: string): string {
+  return text
+    .replace(/\r\n?/g, '\n')
+    .replace(/(\p{L})-\n(\p{L})/gu, '$1$2')
+    .replace(PARAGRAPH_BREAK_RE, '. ')
+    .replace(SOFT_BREAK_RE, ' ')
+}
+
+export function sanitizeTextForSpeech(text: string): string {
+  return normalizeLineBreaks(text)
+    .replace(FENCED_CODE_RE, ' ')
+    .replace(THINKING_PREFIX_RE, ' ')
+    .replace(MARKDOWN_LINK_RE, '$1')
+    .replace(INLINE_CODE_RE, '$1')
+    .replace(URL_RE, ' link ')
+    .replace(EMOJI_RE, ' ')
+    .replace(/^#{1,6}\s+/gm, '')
+    .replace(/[*_~>#]/g, '')
+    .replace(/^\s*[-+*]\s+/gm, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+}

package/src/lib/statusbar.ts

@@ -0,0 +1,91 @@
+import { useEffect, useState } from 'react'
+
+import type { UsageStats } from '@/types/nastech'
+
+export function formatK(value: number): string {
+  if (!Number.isFinite(value) || value <= 0) {
+    return '0'
+  }
+
+  if (value >= 1_000_000) {
+    return `${(value / 1_000_000).toFixed(1)}M`
+  }
+
+  if (value >= 1_000) {
+    return `${(value / 1_000).toFixed(1)}k`
+  }
+
+  return `${Math.round(value)}`
+}
+
+export function formatDuration(elapsedMs: number): string {
+  const totalSeconds = Math.max(0, Math.floor(elapsedMs / 1000))
+  const seconds = totalSeconds % 60
+  const minutes = Math.floor(totalSeconds / 60) % 60
+  const hours = Math.floor(totalSeconds / 3600)
+  const ss = String(seconds).padStart(2, '0')
+  const mm = String(minutes).padStart(2, '0')
+
+  return hours > 0 ? `${hours}:${mm}:${ss}` : `${minutes}:${ss}`
+}
+
+export function compactPath(path: string, max = 44): string {
+  const trimmed = path.trim()
+
+  if (trimmed.length <= max) {
+    return trimmed
+  }
+
+  const segments = trimmed.split('/').filter(Boolean)
+
+  if (segments.length < 2) {
+    return `…${trimmed.slice(-(max - 1))}`
+  }
+
+  const tail = segments.slice(-2).join('/')
+
+  return tail.length + 2 >= max ? `…${tail.slice(-(max - 1))}` : `…/${tail}`
+}
+
+export function contextBar(percent: number | undefined, width = 10): string {
+  const bounded = Math.max(0, Math.min(100, percent ?? 0))
+  const filled = Math.round((bounded / 100) * width)
+
+  return `${'█'.repeat(filled)}${'░'.repeat(width - filled)}`
+}
+
+export function usageContextLabel(usage: UsageStats): string {
+  if (usage.context_max) {
+    return `${formatK(usage.context_used ?? 0)}/${formatK(usage.context_max)}`
+  }
+
+  return usage.total > 0 ? `${formatK(usage.total)} tok` : ''
+}
+
+export function contextBarLabel(usage: UsageStats): string {
+  if (!usage.context_max) {
+    return ''
+  }
+
+  const pct = Math.max(0, Math.min(100, Math.round(usage.context_percent ?? 0)))
+
+  return `[${contextBar(usage.context_percent)}] ${pct}%`
+}
+
+export function LiveDuration({ since }: { since: number | null | undefined }) {
+  const [now, setNow] = useState(() => Date.now())
+
+  useEffect(() => {
+    if (!since) {
+      return
+    }
+
+    const tick = () => setNow(Date.now())
+    tick()
+    const timer = window.setInterval(tick, 1000)
+
+    return () => window.clearInterval(timer)
+  }, [since])
+
+  return since ? formatDuration(now - since) : null
+}

package/src/lib/storage.test.ts

@@ -0,0 +1,25 @@
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import { persistStringArray, storedStringArray } from './storage'
+
+describe('string array storage', () => {
+  beforeEach(() => {
+    window.localStorage.clear()
+  })
+
+  it('removes the key for an empty array', () => {
+    window.localStorage.setItem('test.order', JSON.stringify(['a']))
+
+    persistStringArray('test.order', [])
+
+    expect(window.localStorage.getItem('test.order')).toBeNull()
+    expect(storedStringArray('test.order')).toEqual([])
+  })
+
+  it('persists non-empty arrays', () => {
+    persistStringArray('test.order', ['a', 'b'])
+
+    expect(window.localStorage.getItem('test.order')).toBe(JSON.stringify(['a', 'b']))
+    expect(storedStringArray('test.order')).toEqual(['a', 'b'])
+  })
+})

package/src/lib/storage.ts

@@ -0,0 +1,107 @@
+export function storedBoolean(key: string, fallback: boolean): boolean {
+  try {
+    const value = window.localStorage.getItem(key)
+
+    return value === null ? fallback : value === 'true'
+  } catch {
+    return fallback
+  }
+}
+
+export function persistBoolean(key: string, value: boolean) {
+  try {
+    window.localStorage.setItem(key, String(value))
+  } catch {
+    // Local storage is a convenience; ignore failures in restricted contexts.
+  }
+}
+
+export function storedString(key: string): null | string {
+  try {
+    return window.localStorage.getItem(key)
+  } catch {
+    return null
+  }
+}
+
+export function persistString(key: string, value: null | string) {
+  try {
+    if (value === null) {
+      window.localStorage.removeItem(key)
+    } else {
+      window.localStorage.setItem(key, value)
+    }
+  } catch {
+    // Storage is best-effort.
+  }
+}
+
+export function storedStringArray(key: string): string[] {
+  try {
+    const value = window.localStorage.getItem(key)
+
+    if (!value) {
+      return []
+    }
+
+    const parsed = JSON.parse(value)
+
+    if (!Array.isArray(parsed)) {
+      return []
+    }
+
+    return parsed.filter((item): item is string => typeof item === 'string' && item.length > 0)
+  } catch {
+    return []
+  }
+}
+
+export function persistStringArray(key: string, value: string[]) {
+  try {
+    window.localStorage.setItem(key, JSON.stringify(value))
+  } catch {
+    // Pins are a local preference; restricted storage should not break chat.
+  }
+}
+
+export function storedStringRecord(key: string): Record<string, string> {
+  try {
+    const value = window.localStorage.getItem(key)
+
+    if (!value) {
+      return {}
+    }
+
+    const parsed = JSON.parse(value)
+
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return {}
+    }
+
+    return Object.fromEntries(
+      Object.entries(parsed).filter((entry): entry is [string, string] => typeof entry[1] === 'string')
+    )
+  } catch {
+    return {}
+  }
+}
+
+export function persistStringRecord(key: string, value: Record<string, string>) {
+  try {
+    window.localStorage.setItem(key, JSON.stringify(value))
+  } catch {
+    // Local preference; restricted storage should not break the app.
+  }
+}
+
+export function arraysEqual(left: string[], right: string[]) {
+  return left.length === right.length && left.every((item, index) => item === right[index])
+}
+
+export function insertUniqueId(ids: string[], id: string, index: number) {
+  const next = ids.filter(item => item !== id)
+  const boundedIndex = Math.min(Math.max(index, 0), next.length)
+  next.splice(boundedIndex, 0, id)
+
+  return next
+}

package/src/lib/todos.test.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest'
+
+import { parseTodos } from './todos'
+
+describe('parseTodos', () => {
+  it('parses todo arrays with valid ids, content, and statuses', () => {
+    expect(
+      parseTodos([
+        { content: 'Gather ingredients', id: 'prep', status: 'completed' },
+        { content: 'Boil water', id: 'boil', status: 'in_progress' },
+        { content: 'Serve', id: 'serve', status: 'pending' }
+      ])
+    ).toEqual([
+      { content: 'Gather ingredients', id: 'prep', status: 'completed' },
+      { content: 'Boil water', id: 'boil', status: 'in_progress' },
+      { content: 'Serve', id: 'serve', status: 'pending' }
+    ])
+  })
+
+  it('parses nested todo payloads from wrapped objects and JSON strings', () => {
+    expect(parseTodos({ todos: [{ content: 'Plate', id: 'plate', status: 'pending' }] })).toEqual([
+      { content: 'Plate', id: 'plate', status: 'pending' }
+    ])
+
+    expect(parseTodos('{"todos":[{"id":"plate","content":"Plate","status":"pending"}]}')).toEqual([
+      { content: 'Plate', id: 'plate', status: 'pending' }
+    ])
+  })
+
+  it('returns null for non-todo payloads', () => {
+    expect(parseTodos(undefined)).toBeNull()
+    expect(parseTodos('not json')).toBeNull()
+    expect(parseTodos({ message: 'no todos here' })).toBeNull()
+  })
+})

package/src/lib/todos.ts

@@ -0,0 +1,51 @@
+export type TodoStatus = 'pending' | 'in_progress' | 'completed' | 'cancelled'
+
+export interface TodoItem {
+  content: string
+  id: string
+  status: TodoStatus
+}
+
+const STATUSES: readonly TodoStatus[] = ['pending', 'in_progress', 'completed', 'cancelled']
+
+const isRecord = (v: unknown): v is Record<string, unknown> => Boolean(v && typeof v === 'object' && !Array.isArray(v))
+const isStatus = (v: unknown): v is TodoStatus => (STATUSES as readonly string[]).includes(v as string)
+
+function parseArray(value: unknown[]): TodoItem[] {
+  return value.flatMap(item => {
+    if (!isRecord(item) || !isStatus(item.status)) {
+      return []
+    }
+
+    const id = String(item.id ?? '').trim()
+    const content = String(item.content ?? '').trim()
+
+    return id && content ? [{ content, id, status: item.status }] : []
+  })
+}
+
+function parse(value: unknown, depth: number): null | TodoItem[] {
+  if (depth > 2) {
+    return null
+  }
+
+  if (Array.isArray(value)) {
+    return parseArray(value)
+  }
+
+  if (typeof value === 'string' && value.trim()) {
+    try {
+      return parse(JSON.parse(value), depth + 1)
+    } catch {
+      return null
+    }
+  }
+
+  if (isRecord(value) && Object.hasOwn(value, 'todos')) {
+    return parse(value.todos, depth + 1)
+  }
+
+  return null
+}
+
+export const parseTodos = (value: unknown): null | TodoItem[] => parse(value, 0)

package/src/lib/tool-result-summary.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it } from 'vitest'
+
+import { extractToolErrorMessage, formatToolResultSummary } from './tool-result-summary'
+
+describe('formatToolResultSummary', () => {
+  it('unwraps wrapper payloads into structured key-value lines', () => {
+    const summary = formatToolResultSummary({
+      success: true,
+      result: {
+        data: {
+          path: '/tmp/demo.txt',
+          status: 'ok',
+          lines_written: 12,
+          checksum: 'abc123'
+        }
+      }
+    })
+
+    expect(summary).toContain('- Path: /tmp/demo.txt')
+    expect(summary).toContain('- Status: ok')
+    expect(summary).toContain('- Lines Written: 12')
+    expect(summary).not.toContain('"path"')
+  })
+
+  it('summarizes object arrays as readable list items', () => {
+    const summary = formatToolResultSummary([
+      { title: 'First result', snippet: 'alpha preview text' },
+      { title: 'Second result', status: 'cached' },
+      { title: 'Third result', summary: 'more details' },
+      { title: 'Fourth result', summary: 'line 4' },
+      { title: 'Fifth result', summary: 'line 5' },
+      { title: 'Sixth result', summary: 'line 6' },
+      { title: 'Seventh result', summary: 'line 7' }
+    ])
+
+    expect(summary).toContain('- First result - alpha preview text')
+    expect(summary).toContain('- Second result (cached)')
+    expect(summary).toContain('- … 1 more item')
+  })
+
+  it('truncates long field values for compact display', () => {
+    const summary = formatToolResultSummary({
+      message: 'ok',
+      details: `prefix ${'x'.repeat(500)}`
+    })
+
+    const detailsLine = summary.split('\n').find(line => line.startsWith('- Details:'))
+
+    expect(detailsLine).toBeTruthy()
+    expect(detailsLine?.length).toBeLessThan(230)
+    expect(detailsLine).toContain('…')
+  })
+
+  it('formats stringified json payloads without raw dumps', () => {
+    const summary = formatToolResultSummary(
+      JSON.stringify({
+        data: {
+          title: 'Build report',
+          completed: true
+        }
+      })
+    )
+
+    expect(summary).toContain('- Title: Build report')
+    expect(summary).toContain('- Completed: true')
+  })
+})
+
+describe('extractToolErrorMessage', () => {
+  it('finds nested error messages through wrappers', () => {
+    const error = extractToolErrorMessage({
+      success: false,
+      result: {
+        output: {
+          error: {
+            message: 'Permission denied writing /tmp/demo.txt'
+          }
+        }
+      }
+    })
+
+    expect(error).toBe('Permission denied writing /tmp/demo.txt')
+  })
+
+  it('does not treat successful payload messages as errors', () => {
+    const error = extractToolErrorMessage({
+      success: true,
+      message: 'Completed successfully',
+      data: { count: 3 }
+    })
+
+    expect(error).toBe('')
+  })
+
+  it('ignores placeholder error fields in successful payloads', () => {
+    const error = extractToolErrorMessage({
+      success: true,
+      data: {
+        error: 'none',
+        status: 'ok'
+      }
+    })
+
+    expect(error).toBe('')
+  })
+})