nastechai-desktop 18.1.0

package/src/lib/chat-runtime.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+
+import { coerceThinkingText } from './chat-runtime'
+
+describe('coerceThinkingText', () => {
+  it('strips streaming status prefixes from thinking deltas', () => {
+    expect(coerceThinkingText("◉_◉ processing... checking the user's request")).toBe("checking the user's request")
+    expect(coerceThinkingText('(¬‿¬) analyzing... reading the file')).toBe('reading the file')
+  })
+
+  it('drops empty thinking rewrite placeholder text', () => {
+    expect(
+      coerceThinkingText(
+        "◉_◉ processing... I don't see any current rewritten thinking or next thinking to process. Could you provide the thinking content you'd like me to rewrite?"
+      )
+    ).toBe('')
+  })
+})

package/src/lib/chat-runtime.ts

@@ -0,0 +1,335 @@
+import type { ThreadMessage } from '@assistant-ui/react'
+
+import type { QuickModelOption } from '@/app/chat/composer/types'
+import type { ClientSessionState, CommandDispatchResponse } from '@/app/types'
+import { formatRefValue } from '@/components/assistant-ui/directive-text'
+import { type ChatMessage, type ChatMessagePart, chatMessageText, textPart } from '@/lib/chat-messages'
+import type { ComposerAttachment } from '@/store/composer'
+import type { ModelOptionsResponse, SessionInfo } from '@/types/nastech'
+
+export const SLASH_COMMAND_RE = /^\/[^\s/]*(?:\s|$)/
+export const BUILTIN_PERSONALITIES = [
+  'helpful',
+  'concise',
+  'technical',
+  'creative',
+  'teacher',
+  'kawaii',
+  'catgirl',
+  'pirate',
+  'shakespeare',
+  'surfer',
+  'noir',
+  'uwu',
+  'philosopher',
+  'hype'
+]
+
+const THINKING_STATUS_PREFIX_RE =
+  /^\s*(?:(?:[^\s.]{1,16})\s+)?(?:processing|thinking|reasoning|analyzing|pondering|contemplating|musing|cogitating|ruminating|deliberating|mulling|reflecting|computing|synthesizing|formulating|brainstorming)\.\.\.\s*/i
+
+const EMPTY_THINKING_PLACEHOLDER_RE =
+  /\b(?:current rewritten thinking|next thinking to process|provide the thinking content|don't see any .*thinking)\b/i
+
+export function createClientSessionState(
+  storedSessionId: string | null = null,
+  messages: ChatMessage[] = []
+): ClientSessionState {
+  return {
+    storedSessionId,
+    messages,
+    branch: '',
+    cwd: '',
+    busy: false,
+    awaitingResponse: false,
+    streamId: null,
+    sawAssistantPayload: false,
+    pendingBranchGroup: null,
+    interrupted: false,
+    needsInput: false,
+    turnStartedAt: null
+  }
+}
+
+export function sessionTitle(session: SessionInfo): string {
+  return session.title?.trim() || session.preview?.trim() || 'Untitled session'
+}
+
+export function coerceGatewayText(value: unknown): string {
+  if (typeof value === 'string') {
+    return value
+  }
+
+  if (value === null || value === undefined) {
+    return ''
+  }
+
+  if (Array.isArray(value)) {
+    return value
+      .map(item => {
+        if (typeof item === 'string') {
+          return item
+        }
+
+        if (item && typeof item === 'object') {
+          const row = item as Record<string, unknown>
+
+          if (typeof row.text === 'string') {
+            return row.text
+          }
+
+          if (typeof row.output_text === 'string') {
+            return row.output_text
+          }
+        }
+
+        return ''
+      })
+      .join('')
+  }
+
+  if (typeof value === 'object') {
+    const row = value as Record<string, unknown>
+
+    if (typeof row.text === 'string') {
+      return row.text
+    }
+
+    if (typeof row.output_text === 'string') {
+      return row.output_text
+    }
+
+    try {
+      return JSON.stringify(value)
+    } catch {
+      return ''
+    }
+  }
+
+  return String(value)
+}
+
+/**
+ * Normalize a reasoning/thinking text payload from the gateway.
+ *
+ * Only the leading status prefix (e.g. "NasTech is thinking...") and the
+ * obvious placeholder echoes are stripped. We deliberately do NOT trim
+ * the delta — reasoning streams as small chunks (often individual tokens
+ * with leading or trailing spaces), and trimming each chunk before
+ * concatenation collapses adjacent words together. Whitespace between
+ * tokens belongs to the data, not chrome.
+ */
+export function coerceThinkingText(value: unknown): string {
+  const raw = coerceGatewayText(value).replace(THINKING_STATUS_PREFIX_RE, '')
+
+  return EMPTY_THINKING_PLACEHOLDER_RE.test(raw) ? '' : raw
+}
+
+export function isImageGenerationTool(name?: string): boolean {
+  return name === 'image_generate'
+}
+
+export function contextPath(path: string, cwd: string): string {
+  if (!cwd) {
+    return path
+  }
+
+  const normalizedCwd = cwd.endsWith('/') ? cwd : `${cwd}/`
+
+  return path.startsWith(normalizedCwd) ? path.slice(normalizedCwd.length) : path
+}
+
+export function attachmentId(kind: ComposerAttachment['kind'], value: string): string {
+  return `${kind}:${value}`
+}
+
+export function pathLabel(path: string): string {
+  return path.split(/[\\/]/).filter(Boolean).pop() || path
+}
+
+export function attachmentDisplayText(attachment: ComposerAttachment): string | null {
+  if (attachment.kind === 'terminal' && attachment.detail) {
+    return `\`\`\`terminal\n${attachment.detail.trim()}\n\`\`\``
+  }
+
+  if (attachment.refText) {
+    return attachment.refText
+  }
+
+  if (attachment.kind === 'image') {
+    const id = attachment.detail || attachment.path || attachment.label
+
+    return id ? `@image:${formatRefValue(id)}` : null
+  }
+
+  return null
+}
+
+export function personalityNamesFromConfig(config: unknown): string[] {
+  const root = config && typeof config === 'object' ? (config as Record<string, unknown>) : {}
+  const agent = root.agent && typeof root.agent === 'object' ? (root.agent as Record<string, unknown>) : {}
+  const personalities = agent.personalities
+
+  return personalities && typeof personalities === 'object' && !Array.isArray(personalities)
+    ? Object.keys(personalities as Record<string, unknown>)
+    : []
+}
+
+export function normalizePersonalityValue(value: string): string {
+  const trimmed = value.trim().toLowerCase()
+
+  return !trimmed || trimmed === 'default' || trimmed === 'none' ? '' : trimmed
+}
+
+export function parseSlashCommand(command: string) {
+  const match = command.replace(/^\/+/, '').match(/^(\S+)\s*(.*)$/)
+
+  return match ? { name: match[1], arg: match[2].trim() } : { name: '', arg: '' }
+}
+
+export function parseCommandDispatch(raw: unknown): CommandDispatchResponse | null {
+  if (!raw || typeof raw !== 'object') {
+    return null
+  }
+
+  const row = raw as Record<string, unknown>
+  const str = (value: unknown) => (typeof value === 'string' ? value : undefined)
+
+  switch (row.type) {
+    case 'exec':
+
+    case 'plugin':
+      return { type: row.type, output: str(row.output) }
+
+    case 'alias':
+      return typeof row.target === 'string' ? { type: 'alias', target: row.target } : null
+
+    case 'skill':
+      return typeof row.name === 'string' ? { type: 'skill', name: row.name, message: str(row.message) } : null
+
+    case 'send':
+      return typeof row.message === 'string' ? { type: 'send', message: row.message } : null
+
+    default:
+      return null
+  }
+}
+
+export function quickModelOptions(
+  data: ModelOptionsResponse | undefined,
+  currentProvider: string,
+  currentModel: string
+): QuickModelOption[] {
+  const seen = new Set<string>()
+  const options: QuickModelOption[] = []
+
+  const providers = [...(data?.providers ?? [])].sort((a, b) => {
+    if (a.slug === currentProvider) {
+      return -1
+    }
+
+    if (b.slug === currentProvider) {
+      return 1
+    }
+
+    if (a.is_current) {
+      return -1
+    }
+
+    if (b.is_current) {
+      return 1
+    }
+
+    return 0
+  })
+
+  const add = (provider: string, providerName: string, model: string) => {
+    const key = `${provider}:${model}`
+
+    if (!model || seen.has(key)) {
+      return
+    }
+
+    seen.add(key)
+    options.push({ provider, providerName, model })
+  }
+
+  if (currentProvider && currentModel) {
+    add(currentProvider, currentProvider, currentModel)
+  }
+
+  for (const provider of providers) {
+    const models = [...(provider.models ?? [])].sort((a, b) => {
+      if (provider.slug === currentProvider && a === currentModel) {
+        return -1
+      }
+
+      if (provider.slug === currentProvider && b === currentModel) {
+        return 1
+      }
+
+      return 0
+    })
+
+    for (const model of models) {
+      add(provider.slug, provider.name, model)
+    }
+
+    if (options.length >= 8) {
+      break
+    }
+  }
+
+  return options.slice(0, 8)
+}
+
+export function toRuntimeMessage(message: ChatMessage): ThreadMessage {
+  const role =
+    message.role === 'user' || message.role === 'assistant' || message.role === 'system' ? message.role : 'assistant'
+
+  const createdAt = message.timestamp
+    ? new Date(message.timestamp * 1000)
+    : new Date(Number(message.id.match(/\d+/)?.[0]) || Date.now())
+
+  if (role === 'user') {
+    return {
+      id: message.id,
+      role,
+      content: message.parts.filter((part): part is Extract<ChatMessagePart, { type: 'text' }> => part.type === 'text'),
+      attachments: [],
+      createdAt,
+      metadata: { custom: { attachmentRefs: message.attachmentRefs ?? [] } }
+    } as ThreadMessage
+  }
+
+  if (role === 'system') {
+    const text = chatMessageText(message)
+
+    return {
+      id: message.id,
+      role,
+      content: [textPart(text)],
+      createdAt,
+      metadata: { custom: {} }
+    } as ThreadMessage
+  }
+
+  return {
+    id: message.id,
+    role,
+    content: message.parts as Extract<ThreadMessage, { role: 'assistant' }>['content'],
+    createdAt,
+    status: message.error
+      ? { type: 'incomplete', reason: 'error', error: message.error }
+      : message.pending
+        ? { type: 'running' }
+        : { type: 'complete', reason: 'stop' },
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: {}
+    }
+  } as ThreadMessage
+}

package/src/lib/clipboard.ts

@@ -0,0 +1,28 @@
+// Routes `navigator.clipboard.writeText` through Electron IPC, since the
+// renderer's clipboard API throws "Write permission denied" whenever the
+// document loses focus (e.g. clicking a portaled Radix dropdown). The IPC
+// path runs in the main process and is unconditional.
+
+export function installClipboardShim() {
+  const ipc = window.NASTECHDesktop?.writeClipboard
+
+  if (!ipc || !navigator.clipboard) {
+    return
+  }
+
+  const native = navigator.clipboard.writeText?.bind(navigator.clipboard)
+
+  const writeText = async (text: string) => {
+    try {
+      await ipc(text)
+    } catch {
+      await native?.(text)
+    }
+  }
+
+  try {
+    Object.defineProperty(navigator.clipboard, 'writeText', { configurable: true, value: writeText, writable: true })
+  } catch {
+    // Browser refused override; primitives keep using the native API.
+  }
+}

package/src/lib/commit-changelog.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from 'vitest'
+
+import { buildCommitChangelog, parseCommitHeader } from './commit-changelog'
+
+describe('parseCommitHeader', () => {
+  it('extracts type, scope, and subject from a conventional header', () => {
+    expect(parseCommitHeader('feat(desktop): NSIS prereq detection page')).toEqual({
+      breaking: false,
+      scope: 'desktop',
+      subject: 'NSIS prereq detection page',
+      type: 'feat'
+    })
+  })
+
+  it('flags breaking changes via the `!` marker', () => {
+    expect(parseCommitHeader('feat(api)!: change endpoint shape')).toMatchObject({
+      breaking: true,
+      type: 'feat'
+    })
+  })
+
+  it('treats non-conventional commits as untyped with the full header as subject', () => {
+    expect(parseCommitHeader('Update README')).toEqual({
+      breaking: false,
+      scope: null,
+      subject: 'Update README',
+      type: null
+    })
+  })
+
+  it('ignores body lines and trims whitespace', () => {
+    expect(parseCommitHeader('  fix: handle null input  \n\nMore detail')).toMatchObject({
+      subject: 'handle null input',
+      type: 'fix'
+    })
+  })
+
+  it('returns empty subject for blank input', () => {
+    expect(parseCommitHeader('')).toEqual({ breaking: false, scope: null, subject: '', type: null })
+  })
+})
+
+describe('buildCommitChangelog', () => {
+  it('groups commits into user-friendly buckets and capitalizes subjects', () => {
+    const groups = buildCommitChangelog([
+      { summary: 'feat(desktop): add NSIS prereq detection page' },
+      { summary: 'fix(sidebar): jitter when dragging' },
+      { summary: 'perf: shave 200ms off cold start' },
+      { summary: 'refactor: extract sidebar row component' }
+    ])
+
+    expect(groups.map(g => g.id)).toEqual(['new', 'fixed', 'faster'])
+    expect(groups[0]).toMatchObject({ label: "What's new" })
+    expect(groups[0].items[0]).toBe('Add NSIS prereq detection page')
+    expect(groups[1].items[0]).toBe('Jitter when dragging')
+  })
+
+  it('hides chore/ci/docs/test commits', () => {
+    const groups = buildCommitChangelog([
+      { summary: 'chore: bump deps' },
+      { summary: 'ci: tweak workflow' },
+      { summary: 'docs: spelling fix' },
+      { summary: 'feat: real new feature' }
+    ])
+
+    expect(groups).toHaveLength(1)
+    expect(groups[0].items).toEqual(['Real new feature'])
+  })
+
+  it('routes unparseable commits to the "Other improvements" bucket', () => {
+    const groups = buildCommitChangelog([{ summary: 'Update sidebar styling' }])
+
+    expect(groups[0].id).toBe('other')
+    expect(groups[0].items).toEqual(['Update sidebar styling'])
+  })
+
+  it('falls back to a neutral placeholder when every commit is filtered or empty', () => {
+    const groups = buildCommitChangelog([{ summary: 'chore: bump' }, { summary: 'ci: stuff' }])
+
+    expect(groups).toEqual([{ id: 'other', items: ['Improvements and fixes'], label: 'In this update' }])
+  })
+
+  it('dedupes identical subjects and caps the items per group', () => {
+    const groups = buildCommitChangelog(
+      [
+        { summary: 'fix: thing A' },
+        { summary: 'fix: thing A' },
+        { summary: 'fix: thing B' },
+        { summary: 'fix: thing C' },
+        { summary: 'fix: thing D' },
+        { summary: 'fix: thing E' }
+      ],
+      { maxPerGroup: 3, maxTotal: 10 }
+    )
+
+    expect(groups[0].items).toEqual(['Thing A', 'Thing B', 'Thing C'])
+  })
+
+  it('caps total entries across buckets', () => {
+    const groups = buildCommitChangelog(
+      [
+        { summary: 'feat: a' },
+        { summary: 'feat: b' },
+        { summary: 'fix: c' },
+        { summary: 'fix: d' },
+        { summary: 'perf: e' }
+      ],
+      { maxTotal: 3 }
+    )
+
+    const totalItems = groups.reduce((sum, g) => sum + g.items.length, 0)
+    expect(totalItems).toBe(3)
+  })
+})

package/src/lib/commit-changelog.ts

@@ -0,0 +1,177 @@
+/**
+ * Tiny user-facing changelog builder. Takes a list of raw commit summaries,
+ * parses the Conventional Commits 1.0 header (`type(scope)!: subject`),
+ * filters internal noise (chore/ci/docs/...), and groups the rest into
+ * friendly buckets for end users (What's new, Fixed, Faster, Improved).
+ *
+ * Inlined (rather than depending on `conventional-commits-parser`) because
+ * that package's index re-exports a Node `stream` helper which won't load
+ * in the sandboxed Electron renderer, and its actual parse logic for the
+ * header is a small regex.
+ */
+
+export type CommitGroupId = 'new' | 'fixed' | 'faster' | 'improved' | 'other'
+
+export interface CommitGroup {
+  id: CommitGroupId
+  label: string
+  items: string[]
+}
+
+export interface ParsedCommit {
+  type: null | string
+  scope: null | string
+  breaking: boolean
+  subject: string
+}
+
+export interface CommitChangelogInput {
+  summary?: string
+}
+
+interface BuildOptions {
+  maxGroups?: number
+  maxPerGroup?: number
+  maxTotal?: number
+}
+
+const GROUP_META: Record<CommitGroupId, { label: string; order: number }> = {
+  new: { label: "What's new", order: 0 },
+  fixed: { label: 'Fixed', order: 1 },
+  faster: { label: 'Faster', order: 2 },
+  improved: { label: 'Improved', order: 3 },
+  other: { label: 'Other improvements', order: 4 }
+}
+
+const TYPE_TO_GROUP: Record<string, CommitGroupId> = {
+  feat: 'new',
+  feature: 'new',
+  fix: 'fixed',
+  bugfix: 'fixed',
+  hotfix: 'fixed',
+  revert: 'fixed',
+  perf: 'faster',
+  performance: 'faster',
+  refactor: 'improved',
+  a11y: 'improved',
+  ui: 'improved',
+  ux: 'improved'
+}
+
+const HIDDEN_TYPES = new Set([
+  'build',
+  'chore',
+  'ci',
+  'dep',
+  'deps',
+  'doc',
+  'docs',
+  'lint',
+  'release',
+  'style',
+  'test',
+  'tests',
+  'wip'
+])
+
+const FALLBACK_GROUP: CommitGroup = { id: 'other', items: ['Improvements and fixes'], label: 'In this update' }
+
+const CONVENTIONAL_HEADER = /^(?<type>[a-zA-Z][a-zA-Z0-9_-]*)(?:\((?<scope>[^)]+)\))?(?<bang>!)?:\s+(?<subject>.+)$/
+
+/** Parse a single commit header line per Conventional Commits 1.0. */
+export function parseCommitHeader(raw: string): ParsedCommit {
+  const header = (raw ?? '').split(/\r?\n/, 1)[0].trim()
+
+  if (!header) {
+    return { breaking: false, scope: null, subject: '', type: null }
+  }
+
+  const match = CONVENTIONAL_HEADER.exec(header)
+
+  if (!match?.groups) {
+    return { breaking: false, scope: null, subject: header, type: null }
+  }
+
+  return {
+    breaking: Boolean(match.groups.bang),
+    scope: match.groups.scope ?? null,
+    subject: match.groups.subject.trim(),
+    type: match.groups.type.toLowerCase()
+  }
+}
+
+function tidySubject(subject: string): string {
+  const cleaned = subject
+    .replace(/\s+/g, ' ')
+    .replace(/[.;,\s]+$/, '')
+    .trim()
+
+  if (!cleaned) {
+    return cleaned
+  }
+
+  return cleaned.charAt(0).toUpperCase() + cleaned.slice(1)
+}
+
+/**
+ * Build a small grouped changelog from a list of raw commits.
+ * Always returns at least one group; falls back to a neutral placeholder
+ * when every commit was filtered or unparseable.
+ */
+export function buildCommitChangelog(
+  commits: readonly CommitChangelogInput[] | undefined,
+  options: BuildOptions = {}
+): CommitGroup[] {
+  const { maxGroups = 3, maxPerGroup = 4, maxTotal = 6 } = options
+  const groups = new Map<CommitGroupId, string[]>()
+  const seen = new Set<string>()
+  let total = 0
+
+  for (const commit of commits ?? []) {
+    if (total >= maxTotal) {
+      break
+    }
+
+    const parsed = parseCommitHeader(commit.summary ?? '')
+
+    if (parsed.type && HIDDEN_TYPES.has(parsed.type)) {
+      continue
+    }
+
+    const groupId: CommitGroupId = parsed.type ? (TYPE_TO_GROUP[parsed.type] ?? 'other') : 'other'
+    const subject = tidySubject(parsed.subject)
+
+    if (!subject) {
+      continue
+    }
+
+    const dedupeKey = subject.toLowerCase()
+
+    if (seen.has(dedupeKey)) {
+      continue
+    }
+
+    const bucket = groups.get(groupId) ?? []
+
+    if (bucket.length >= maxPerGroup) {
+      continue
+    }
+
+    bucket.push(subject)
+    groups.set(groupId, bucket)
+    seen.add(dedupeKey)
+    total += 1
+  }
+
+  const result = Array.from(groups.entries())
+    .map(([id, items]) => ({ id, items, label: GROUP_META[id].label, order: GROUP_META[id].order }))
+    .sort((a, b) => a.order - b.order)
+    .slice(0, maxGroups)
+    .map(({ id, items, label }): CommitGroup => ({ id, items, label }))
+
+  if (result.length === 0) {
+    return [FALLBACK_GROUP]
+  }
+
+  return result
+}