nastechai-desktop 18.1.0

package/src/app/chat/composer/hooks/use-at-completions.ts

@@ -0,0 +1,141 @@
+import type { Unstable_TriggerAdapter, Unstable_TriggerItem } from '@assistant-ui/core'
+import { useCallback } from 'react'
+
+import type { NasTechGateway } from '@/nastech'
+
+import type { CompletionEntry, CompletionPayload } from './use-live-completion-adapter'
+import { useLiveCompletionAdapter } from './use-live-completion-adapter'
+
+const KIND_RE = /^@(file|folder|url|image|tool|git):(.*)$/
+const REF_STARTERS = new Set(['file', 'folder', 'url', 'image', 'tool', 'git'])
+
+const STARTER_META: Record<string, string> = {
+  file: 'Attach a file reference',
+  folder: 'Attach a folder reference',
+  url: 'Attach a URL reference',
+  image: 'Attach an image reference',
+  tool: 'Attach a tool reference',
+  git: 'Attach git context'
+}
+
+function starterEntries(query: string): CompletionEntry[] {
+  const q = query.trim().toLowerCase()
+  const kinds = Array.from(REF_STARTERS)
+  const filtered = q ? kinds.filter(kind => kind.startsWith(q)) : kinds
+
+  return filtered.map(kind => ({
+    text: `@${kind}:`,
+    display: `@${kind}:`,
+    meta: STARTER_META[kind] || ''
+  }))
+}
+
+interface AtItemMetadata extends Record<string, string> {
+  icon: string
+  display: string
+  meta: string
+  /** Raw `text` field from the gateway, e.g. `@file:src/main.tsx` or `@diff`. */
+  rawText: string
+  /** Just the value portion (after `@kind:`), or empty for simple refs. */
+  insertId: string
+}
+
+function textValue(value: unknown, fallback = ''): string {
+  return typeof value === 'string' ? value : fallback
+}
+
+/** Parse the gateway's `text` field (`@file:src/foo.ts`, `@diff`, `@folder:`) into popover-ready data. */
+function classify(entry: CompletionEntry): {
+  type: string
+  insertId: string
+  display: string
+  meta: string
+} {
+  const match = KIND_RE.exec(entry.text)
+
+  if (match) {
+    const [, kind, rest] = match
+
+    return {
+      type: kind,
+      insertId: rest,
+      display: textValue(entry.display, rest || `@${kind}:`),
+      meta: textValue(entry.meta)
+    }
+  }
+
+  return {
+    type: 'simple',
+    insertId: entry.text,
+    display: textValue(entry.display, entry.text),
+    meta: textValue(entry.meta)
+  }
+}
+
+/** Live `@` completions backed by the gateway's `complete.path` RPC. */
+export function useAtCompletions(options: {
+  gateway: NasTechGateway | null
+  sessionId: string | null
+  cwd: string | null
+}): { adapter: Unstable_TriggerAdapter; loading: boolean } {
+  const { gateway, sessionId, cwd } = options
+  const enabled = Boolean(gateway)
+
+  const fetcher = useCallback(
+    async (query: string): Promise<CompletionPayload> => {
+      const starters = starterEntries(query)
+
+      if (!gateway) {
+        return { items: starters, query }
+      }
+
+      const word = REF_STARTERS.has(query) ? `@${query}:` : `@${query}`
+      const params: Record<string, unknown> = { word }
+
+      if (sessionId) {
+        params.session_id = sessionId
+      }
+
+      if (cwd) {
+        params.cwd = cwd
+      }
+
+      try {
+        const result = await gateway.request<{ items?: CompletionEntry[] }>('complete.path', params)
+        const items = result.items ?? []
+
+        return { items: items.length > 0 ? items : starters, query }
+      } catch {
+        return { items: starters, query }
+      }
+    },
+    [gateway, sessionId, cwd]
+  )
+
+  const toItem = useCallback((entry: CompletionEntry, index: number): Unstable_TriggerItem => {
+    const classified = classify(entry)
+
+    const metadata: AtItemMetadata = {
+      icon: classified.type,
+      display: classified.display,
+      meta: classified.meta,
+      rawText: entry.text,
+      insertId: classified.insertId
+    }
+
+    return {
+      // Unique id keyed on the gateway's full `text` so two entries that share
+      // a basename (e.g. multiple `index.ts`) don't collide in keyboard nav.
+      id: `${entry.text}|${index}`,
+      type: classified.type,
+      label: classified.display,
+      ...(classified.meta ? { description: classified.meta } : {}),
+      metadata
+    }
+  }, [])
+
+  return useLiveCompletionAdapter({ enabled, fetcher, toItem })
+}
+
+/** Re-export `classify` for use by the formatter (insertion side). */
+export { classify }

package/src/app/chat/composer/hooks/use-live-completion-adapter.ts

@@ -0,0 +1,119 @@
+import type { Unstable_TriggerAdapter, Unstable_TriggerItem } from '@assistant-ui/core'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+
+export interface CompletionEntry {
+  text: string
+  display?: unknown
+  meta?: unknown
+}
+
+export interface CompletionPayload {
+  items: CompletionEntry[]
+  query: string
+}
+
+const EMPTY_QUERY = '\u0000'
+
+export function useLiveCompletionAdapter(options: {
+  enabled: boolean
+  debounceMs?: number
+  fetcher: (query: string) => Promise<CompletionPayload>
+  toItem: (entry: CompletionEntry, index: number) => Unstable_TriggerItem
+}): { adapter: Unstable_TriggerAdapter; loading: boolean } {
+  const { enabled, debounceMs = 60, fetcher, toItem } = options
+
+  const [state, setState] = useState<{ query: string; items: Unstable_TriggerItem[] }>({
+    query: EMPTY_QUERY,
+    items: []
+  })
+
+  const [loading, setLoading] = useState(false)
+
+  const tokenRef = useRef(0)
+  const timerRef = useRef<number | null>(null)
+  const pendingQueryRef = useRef<string | null>(null)
+
+  const cancelTimer = useCallback(() => {
+    if (timerRef.current !== null) {
+      window.clearTimeout(timerRef.current)
+      timerRef.current = null
+    }
+  }, [])
+
+  useEffect(() => () => cancelTimer(), [cancelTimer])
+
+  useEffect(() => {
+    if (enabled) {
+      return
+    }
+
+    cancelTimer()
+    pendingQueryRef.current = null
+    tokenRef.current += 1
+    setLoading(false)
+    setState({ query: EMPTY_QUERY, items: [] })
+  }, [cancelTimer, enabled])
+
+  const scheduleFetch = useCallback(
+    (query: string) => {
+      if (!enabled) {
+        return
+      }
+
+      if (pendingQueryRef.current === query) {
+        return
+      }
+
+      pendingQueryRef.current = query
+      cancelTimer()
+      const token = ++tokenRef.current
+      setLoading(true)
+
+      timerRef.current = window.setTimeout(() => {
+        timerRef.current = null
+
+        fetcher(query)
+          .then(payload => {
+            if (token !== tokenRef.current) {
+              return
+            }
+
+            setState({
+              query: payload.query,
+              items: payload.items.map((entry, index) => toItem(entry, index))
+            })
+          })
+          .catch(() => {
+            if (token !== tokenRef.current) {
+              return
+            }
+
+            setState({ query, items: [] })
+          })
+          .finally(() => {
+            if (token === tokenRef.current) {
+              setLoading(false)
+            }
+          })
+      }, debounceMs)
+    },
+    [cancelTimer, debounceMs, enabled, fetcher, toItem]
+  )
+
+  const adapter = useMemo<Unstable_TriggerAdapter>(
+    () => ({
+      categories: () => [],
+      categoryItems: () => [],
+      search: (query: string) => {
+        if (query !== state.query) {
+          scheduleFetch(query)
+        }
+
+        return state.items
+      }
+    }),
+    [scheduleFetch, state]
+  )
+
+  return { adapter, loading }
+}

package/src/app/chat/composer/hooks/use-mic-recorder.ts

@@ -0,0 +1,291 @@
+import { useEffect, useRef, useState } from 'react'
+
+type BrowserAudioContext = typeof AudioContext
+
+export interface MicRecorderOptions {
+  onLevel?: (level: number) => void
+  onError?: (error: Error) => void
+  onSilence?: () => void
+  silenceLevel?: number
+  silenceMs?: number
+  idleSilenceMs?: number
+}
+
+export interface MicRecording {
+  audio: Blob
+  durationMs: number
+  heardSpeech: boolean
+}
+
+export interface MicRecorderErrorCopy {
+  microphoneAccessDenied: string
+  microphoneConstraintsUnsupported: string
+  microphoneInUse: string
+  microphonePermissionDenied: string
+  microphoneStartFailed: string
+  microphoneUnsupported: string
+  noMicrophone: string
+}
+
+interface MicRecorderHandle {
+  start: (options?: MicRecorderOptions) => Promise<void>
+  stop: () => Promise<MicRecording | null>
+  cancel: () => void
+}
+
+function micError(error: unknown, copy: MicRecorderErrorCopy): Error {
+  const name = error instanceof DOMException ? error.name : ''
+
+  if (name === 'NotAllowedError' || name === 'SecurityError') {
+    return new Error(copy.microphonePermissionDenied)
+  }
+
+  if (name === 'NotFoundError' || name === 'DevicesNotFoundError') {
+    return new Error(copy.noMicrophone)
+  }
+
+  if (name === 'NotReadableError' || name === 'TrackStartError') {
+    return new Error(copy.microphoneInUse)
+  }
+
+  if (name === 'OverconstrainedError') {
+    return new Error(copy.microphoneConstraintsUnsupported)
+  }
+
+  if (error instanceof Error) {
+    return error
+  }
+
+  return new Error(copy.microphoneStartFailed)
+}
+
+export function useMicRecorder(copy: MicRecorderErrorCopy): { handle: MicRecorderHandle; level: number; recording: boolean } {
+  const [level, setLevel] = useState(0)
+  const [recording, setRecording] = useState(false)
+
+  const recorderRef = useRef<MediaRecorder | null>(null)
+  const streamRef = useRef<MediaStream | null>(null)
+  const chunksRef = useRef<Blob[]>([])
+  const audioContextRef = useRef<AudioContext | null>(null)
+  const animationRef = useRef<number | null>(null)
+  const startedAtRef = useRef(0)
+  const heardSpeechRef = useRef(false)
+  const silenceTriggeredRef = useRef(false)
+  const silenceStartedAtRef = useRef<number | null>(null)
+  const stopResolverRef = useRef<((recording: MicRecording | null) => void) | null>(null)
+
+  const cleanup = () => {
+    if (animationRef.current) {
+      window.cancelAnimationFrame(animationRef.current)
+      animationRef.current = null
+    }
+
+    void audioContextRef.current?.close()
+    audioContextRef.current = null
+    streamRef.current?.getTracks().forEach(track => track.stop())
+    streamRef.current = null
+    recorderRef.current = null
+    setLevel(0)
+    setRecording(false)
+    silenceTriggeredRef.current = false
+  }
+
+  useEffect(() => () => cleanup(), [])
+
+  const startMeter = (stream: MediaStream, options: MicRecorderOptions) => {
+    const audioWindow = window as Window & { webkitAudioContext?: BrowserAudioContext }
+    const AudioContextCtor = window.AudioContext || audioWindow.webkitAudioContext
+
+    if (!AudioContextCtor) {
+      return
+    }
+
+    try {
+      const audioContext = new AudioContextCtor()
+      const analyser = audioContext.createAnalyser()
+      const source = audioContext.createMediaStreamSource(stream)
+
+      analyser.fftSize = 256
+      const data = new Uint8Array(analyser.fftSize)
+
+      source.connect(analyser)
+      audioContextRef.current = audioContext
+
+      const tick = () => {
+        analyser.getByteTimeDomainData(data)
+
+        let sum = 0
+
+        for (const value of data) {
+          const centered = value - 128
+          sum += centered * centered
+        }
+
+        const rms = Math.sqrt(sum / data.length)
+        const normalized = Math.min(1, rms / 42)
+        const now = Date.now()
+
+        setLevel(normalized)
+        options.onLevel?.(normalized)
+
+        const speechThreshold = options.silenceLevel ?? 0
+        const silenceMs = options.silenceMs ?? 0
+        const idleSilenceMs = options.idleSilenceMs ?? 0
+
+        if (speechThreshold > 0 && options.onSilence && !silenceTriggeredRef.current) {
+          if (normalized >= speechThreshold) {
+            heardSpeechRef.current = true
+            silenceStartedAtRef.current = null
+          } else if (heardSpeechRef.current && silenceMs > 0) {
+            silenceStartedAtRef.current ??= now
+
+            if (now - silenceStartedAtRef.current >= silenceMs) {
+              silenceTriggeredRef.current = true
+              options.onSilence()
+
+              return
+            }
+          } else if (!heardSpeechRef.current && idleSilenceMs > 0 && now - startedAtRef.current >= idleSilenceMs) {
+            silenceTriggeredRef.current = true
+            options.onSilence()
+
+            return
+          }
+        }
+
+        animationRef.current = window.requestAnimationFrame(tick)
+      }
+
+      tick()
+    } catch {
+      setLevel(0)
+    }
+  }
+
+  const start: MicRecorderHandle['start'] = async (options = {}) => {
+    if (recorderRef.current) {
+      return
+    }
+
+    if (!navigator.mediaDevices?.getUserMedia || typeof MediaRecorder === 'undefined') {
+      throw new Error(copy.microphoneUnsupported)
+    }
+
+    const permitted = await window.NASTECHDesktop?.requestMicrophoneAccess?.()
+
+    if (permitted === false) {
+      throw new Error(copy.microphoneAccessDenied)
+    }
+
+    let stream: MediaStream
+
+    try {
+      stream = await navigator.mediaDevices.getUserMedia({
+        audio: { echoCancellation: true, noiseSuppression: true }
+      })
+    } catch (error) {
+      throw micError(error, copy)
+    }
+
+    const mimeType =
+      ['audio/webm;codecs=opus', 'audio/webm', 'audio/mp4', 'audio/ogg;codecs=opus', 'audio/ogg', 'audio/wav'].find(
+        type => MediaRecorder.isTypeSupported(type)
+      ) ?? ''
+
+    let recorder: MediaRecorder
+
+    try {
+      recorder = new MediaRecorder(stream, mimeType ? { mimeType } : undefined)
+    } catch (error) {
+      stream.getTracks().forEach(track => track.stop())
+      throw micError(error, copy)
+    }
+
+    chunksRef.current = []
+    streamRef.current = stream
+    recorderRef.current = recorder
+    heardSpeechRef.current = false
+    silenceTriggeredRef.current = false
+    silenceStartedAtRef.current = null
+    startedAtRef.current = Date.now()
+
+    recorder.ondataavailable = event => {
+      if (event.data.size > 0) {
+        chunksRef.current.push(event.data)
+      }
+    }
+
+    recorder.onstop = () => {
+      const chunks = chunksRef.current
+      const recordingType = recorder.mimeType || mimeType || 'audio/webm'
+      const durationMs = Date.now() - startedAtRef.current
+      const heardSpeech = heardSpeechRef.current
+
+      chunksRef.current = []
+      cleanup()
+
+      const resolver = stopResolverRef.current
+      stopResolverRef.current = null
+
+      if (!chunks.length) {
+        resolver?.(null)
+
+        return
+      }
+
+      resolver?.({
+        audio: new Blob(chunks, { type: recordingType }),
+        durationMs,
+        heardSpeech
+      })
+    }
+
+    recorder.onerror = event => {
+      const error = micError((event as Event & { error?: unknown }).error, copy)
+      const resolver = stopResolverRef.current
+      stopResolverRef.current = null
+      cleanup()
+      options.onError?.(error)
+      resolver?.(null)
+    }
+
+    recorder.start()
+    setRecording(true)
+    startMeter(stream, options)
+  }
+
+  const stop: MicRecorderHandle['stop'] = () =>
+    new Promise<MicRecording | null>(resolve => {
+      const recorder = recorderRef.current
+
+      if (!recorder || recorder.state === 'inactive') {
+        cleanup()
+        resolve(null)
+
+        return
+      }
+
+      stopResolverRef.current = resolve
+      recorder.stop()
+    })
+
+  const cancel: MicRecorderHandle['cancel'] = () => {
+    const recorder = recorderRef.current
+    const resolver = stopResolverRef.current
+    stopResolverRef.current = null
+
+    if (recorder && recorder.state !== 'inactive') {
+      recorder.ondataavailable = null
+      recorder.onerror = null
+      recorder.onstop = null
+      recorder.stop()
+    }
+
+    cleanup()
+    resolver?.(null)
+  }
+
+  const handle: MicRecorderHandle = { start, stop, cancel }
+
+  return { handle, level, recording }
+}

package/src/app/chat/composer/hooks/use-slash-completions.ts

@@ -0,0 +1,114 @@
+import type { Unstable_TriggerAdapter, Unstable_TriggerItem } from '@assistant-ui/core'
+import { useCallback } from 'react'
+
+import type { NasTechGateway } from '@/nastech'
+import {
+  type CommandsCatalogLike,
+  desktopSlashDescription,
+  filterDesktopCommandsCatalog,
+  isDesktopSlashSuggestion
+} from '@/lib/desktop-slash-commands'
+
+import type { CompletionEntry, CompletionPayload } from './use-live-completion-adapter'
+import { useLiveCompletionAdapter } from './use-live-completion-adapter'
+
+interface SlashItemMetadata extends Record<string, string> {
+  command: string
+  display: string
+  meta: string
+  rawText: string
+}
+
+function textValue(value: unknown, fallback = ''): string {
+  if (typeof value === 'string') {
+    return value
+  }
+
+  if (Array.isArray(value)) {
+    return value
+      .map(part => (Array.isArray(part) ? String(part[1] ?? '') : typeof part === 'string' ? part : ''))
+      .join('')
+      .trim()
+  }
+
+  return fallback
+}
+
+function commandText(value: string): string {
+  return value.startsWith('/') ? value : `/${value}`
+}
+
+/** Live `/` completions backed by the gateway's `complete.slash` RPC. */
+export function useSlashCompletions(options: { gateway: NasTechGateway | null }): {
+  adapter: Unstable_TriggerAdapter
+  loading: boolean
+} {
+  const { gateway } = options
+  const enabled = Boolean(gateway)
+
+  const fetcher = useCallback(
+    async (query: string): Promise<CompletionPayload> => {
+      if (!gateway) {
+        return { items: [], query }
+      }
+
+      const text = `/${query}`
+
+      try {
+        if (!query) {
+          const catalog = filterDesktopCommandsCatalog(await gateway.request<CommandsCatalogLike>('commands.catalog'))
+
+          const items = (catalog.pairs ?? []).map(([command, meta]) => ({
+            text: command,
+            display: command,
+            meta
+          }))
+
+          return { items, query }
+        }
+
+        const result = await gateway.request<{ items?: CompletionEntry[] }>('complete.slash', { text })
+
+        const items = (result.items ?? [])
+          .filter(item => isDesktopSlashSuggestion(item.text))
+          .map(item => ({
+            ...item,
+            meta: desktopSlashDescription(item.text, textValue(item.meta))
+          }))
+
+        return { items, query }
+      } catch {
+        return { items: [], query }
+      }
+    },
+    [gateway]
+  )
+
+  const toItem = useCallback((entry: CompletionEntry, index: number): Unstable_TriggerItem => {
+    const command = commandText(entry.text)
+    const display = textValue(entry.display, commandText(entry.text))
+    const meta = textValue(entry.meta)
+
+    const metadata: SlashItemMetadata = {
+      command,
+      display,
+      meta,
+      // Provide rawText so NASTECHDirectiveFormatter.serialize uses the
+      // direct-insertion path instead of the legacy @type:id fallback.
+      // Without this, the item.id (which includes a "|index" suffix for
+      // trigger-adapter uniqueness) leaks into the serialized chip text
+      // and the submitted command.
+      rawText: command
+    }
+
+    return {
+      id: `${entry.text}|${index}`,
+      type: 'slash',
+      label: display.startsWith('/') ? display.slice(1) : display,
+      ...(meta ? { description: meta } : {}),
+      metadata
+    }
+  }, [])
+
+  return useLiveCompletionAdapter({ enabled, fetcher, toItem })
+}