@pheem49/mint 1.8.1 → 1.9.0

package/src/renderer/shared/utils/speech.ts

@@ -0,0 +1,216 @@
+import { useState, useRef, useEffect } from 'react'
+
+export interface SpeechToTextOptions {
+  language?: string
+  message: string
+  sending: boolean
+  isSpeaking: boolean
+  onSendVoiceMessage: (text: string) => Promise<any>
+  onSetMessage: (text: string) => void
+}
+
+export function useSpeechToText({
+  language,
+  message,
+  sending,
+  isSpeaking,
+  onSendVoiceMessage,
+  onSetMessage
+}: SpeechToTextOptions) {
+  const [isRecording, setIsRecording] = useState(false)
+  const [voiceMode, setVoiceMode] = useState(false)
+  const [voiceTranscript, setVoiceTranscript] = useState('')
+  const [voiceAwaitingResponse, setVoiceAwaitingResponse] = useState(false)
+
+  const recognitionRef = useRef<any>(null)
+  const silenceTimerRef = useRef<number | null>(null)
+  const restartTimerRef = useRef<number | null>(null)
+
+  const voiceModeRef = useRef(false)
+  const sendingRef = useRef(false)
+  const voiceAwaitingResponseRef = useRef(false)
+  const isSpeakingRef = useRef(false)
+  const messageRef = useRef(message)
+
+  // Sync state to refs for event handlers
+  useEffect(() => {
+    voiceModeRef.current = voiceMode
+    if (!voiceMode) {
+      clearRestartTimer()
+      setVoiceTranscript('')
+    }
+  }, [voiceMode])
+
+  useEffect(() => {
+    sendingRef.current = sending
+  }, [sending])
+
+  useEffect(() => {
+    voiceAwaitingResponseRef.current = voiceAwaitingResponse
+  }, [voiceAwaitingResponse])
+
+  useEffect(() => {
+    isSpeakingRef.current = isSpeaking
+  }, [isSpeaking])
+
+  useEffect(() => {
+    messageRef.current = message
+  }, [message])
+
+  const clearRestartTimer = () => {
+    if (restartTimerRef.current !== null) {
+      window.clearTimeout(restartTimerRef.current)
+      restartTimerRef.current = null
+    }
+  }
+
+  const clearSilenceTimer = () => {
+    if (silenceTimerRef.current !== null) {
+      window.clearTimeout(silenceTimerRef.current)
+      silenceTimerRef.current = null
+    }
+  }
+
+  const stopRecognition = () => {
+    clearRestartTimer()
+    clearSilenceTimer()
+    recognitionRef.current?.stop()
+    recognitionRef.current = null
+    setIsRecording(false)
+  }
+
+  const scheduleVoiceListen = (delayMs = 350) => {
+    clearRestartTimer()
+    if (!voiceModeRef.current || sendingRef.current || voiceAwaitingResponseRef.current || isSpeakingRef.current) return
+    restartTimerRef.current = window.setTimeout(() => {
+      restartTimerRef.current = null
+      startRecognition(true)
+    }, delayMs)
+  }
+
+  const startRecognition = (autoSend: boolean) => {
+    if (recognitionRef.current || sendingRef.current || voiceAwaitingResponseRef.current || isSpeakingRef.current) return
+
+    const SpeechRecognitionApi = (window as any).SpeechRecognition || (window as any).webkitSpeechRecognition
+    if (!SpeechRecognitionApi) {
+      alert('Speech-to-text (Speech Recognition) is not supported in this browser/WebView. Please use Google Chrome or Microsoft Edge to enable voice conversation.')
+      voiceModeRef.current = false
+      setVoiceMode(false)
+      return
+    }
+
+    let accumulatedTranscript = ''
+    clearSilenceTimer()
+
+    try {
+      const recognition = new SpeechRecognitionApi()
+      recognition.continuous = true
+      recognition.interimResults = true
+      recognition.lang = language === 'en' ? 'en-US' : 'th-TH'
+
+      const resetSilenceTimeout = () => {
+        clearSilenceTimer()
+        if (autoSend) {
+          silenceTimerRef.current = window.setTimeout(() => {
+            recognition.stop()
+          }, 2000)
+        }
+      }
+
+      recognition.onstart = () => {
+        setIsRecording(true)
+      }
+      recognition.onresult = (event: any) => {
+        let interimText = ''
+        let finalText = ''
+        for (let index = event.resultIndex; index < event.results.length; index += 1) {
+          const transcript = event.results[index]?.[0]?.transcript ?? ''
+          if (event.results[index]?.isFinal) {
+            finalText += transcript
+          } else {
+            interimText += transcript
+          }
+        }
+        const displayText = (finalText || interimText).trim()
+        if (displayText) setVoiceTranscript(displayText)
+        if (finalText.trim()) {
+          accumulatedTranscript = finalText.trim()
+        }
+        if (displayText) {
+          resetSilenceTimeout()
+        }
+      }
+      recognition.onerror = (event: any) => {
+        console.error('Speech recognition error', event)
+        setIsRecording(false)
+        clearSilenceTimer()
+      }
+      recognition.onend = () => {
+        recognitionRef.current = null
+        setIsRecording(false)
+        clearSilenceTimer()
+        const finalText = accumulatedTranscript.trim()
+        if (finalText) {
+          if (autoSend) {
+            voiceAwaitingResponseRef.current = true
+            setVoiceAwaitingResponse(true)
+            onSendVoiceMessage(finalText)
+              .catch((error: any) => console.error('Voice message failed', error))
+              .finally(() => {
+                voiceAwaitingResponseRef.current = false
+                setVoiceAwaitingResponse(false)
+                scheduleVoiceListen()
+              })
+          } else {
+            onSetMessage(messageRef.current.trim() ? `${messageRef.current.trimEnd()} ${finalText}` : finalText)
+          }
+        } else {
+          if (autoSend && voiceModeRef.current) scheduleVoiceListen()
+        }
+      }
+      recognitionRef.current = recognition
+      recognition.start()
+    } catch (error) {
+      console.error('Failed to start speech recognition', error)
+      recognitionRef.current = null
+      setIsRecording(false)
+      clearSilenceTimer()
+    }
+  }
+
+  // Auto-listen trigger
+  useEffect(() => {
+    if (!voiceMode || sending || voiceAwaitingResponse || isSpeaking || isRecording) return
+    scheduleVoiceListen()
+  }, [voiceMode, sending, voiceAwaitingResponse, isSpeaking, isRecording])
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      clearRestartTimer()
+      clearSilenceTimer()
+      if (recognitionRef.current) {
+        try {
+          recognitionRef.current.stop()
+        } catch (e) {
+          // ignore
+        }
+      }
+    }
+  }, [])
+
+  return {
+    isRecording,
+    voiceMode,
+    setVoiceMode,
+    voiceTranscript,
+    setVoiceTranscript,
+    voiceAwaitingResponse,
+    voiceAwaitingResponseRef,
+    voiceModeRef,
+    startRecognition,
+    stopRecognition,
+    scheduleVoiceListen,
+    clearRestartTimer
+  }
+}

package/src/renderer/shared/utils/ui.ts

@@ -0,0 +1,147 @@
+/**
+ * shared/utils/ui.ts
+ * Shared UI and theme helper functions.
+ * Used by both Desktop and Web components.
+ */
+
+export function numericSetting(value: unknown, fallback: number): number {
+  const numeric = Number(value)
+  return Number.isFinite(numeric) ? numeric : fallback
+}
+
+export function errorMessage(reason: unknown): string {
+  return reason instanceof Error ? reason.message : String(reason)
+}
+
+export function readImage(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader()
+    reader.onload = () => resolve(String(reader.result))
+    reader.onerror = () => reject(reader.error ?? new Error('Unable to read image'))
+    reader.readAsDataURL(file)
+  })
+}
+
+export function readDocument(file: File): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader()
+    reader.onload = () => resolve(String(reader.result))
+    reader.onerror = () => reject(reader.error ?? new Error('Unable to read document'))
+    reader.readAsDataURL(file)
+  })
+}
+
+export async function createTrimmedImagePreview(dataUri: string): Promise<string> {
+  const image = await new Promise<HTMLImageElement>((resolve, reject) => {
+    const nextImage = new Image()
+    nextImage.onload = () => resolve(nextImage)
+    nextImage.onerror = () => reject(new Error('Unable to prepare image preview'))
+    nextImage.src = dataUri
+  })
+
+  const canvas = document.createElement('canvas')
+  canvas.width = image.naturalWidth || image.width
+  canvas.height = image.naturalHeight || image.height
+  const context = canvas.getContext('2d', { willReadFrequently: true })
+  if (!context || canvas.width === 0 || canvas.height === 0) return dataUri
+
+  context.drawImage(image, 0, 0)
+  const pixels = context.getImageData(0, 0, canvas.width, canvas.height)
+  let minX = canvas.width
+  let minY = canvas.height
+  let maxX = -1
+  let maxY = -1
+
+  for (let y = 0; y < canvas.height; y += 1) {
+    for (let x = 0; x < canvas.width; x += 1) {
+      const alpha = pixels.data[(y * canvas.width + x) * 4 + 3]
+      if (alpha > 12) {
+        minX = Math.min(minX, x)
+        minY = Math.min(minY, y)
+        maxX = Math.max(maxX, x)
+        maxY = Math.max(maxY, y)
+      }
+    }
+  }
+
+  if (maxX < minX || maxY < minY) return dataUri
+
+  const padding = 8
+  const sx = Math.max(0, minX - padding)
+  const sy = Math.max(0, minY - padding)
+  const sw = Math.min(canvas.width - sx, maxX - minX + 1 + padding * 2)
+  const sh = Math.min(canvas.height - sy, maxY - minY + 1 + padding * 2)
+
+  if (sw >= canvas.width * 0.92 && sh >= canvas.height * 0.92) return dataUri
+
+  const previewCanvas = document.createElement('canvas')
+  previewCanvas.width = sw
+  previewCanvas.height = sh
+  const previewContext = previewCanvas.getContext('2d')
+  if (!previewContext) return dataUri
+  previewContext.drawImage(canvas, sx, sy, sw, sh, 0, 0, sw, sh)
+  return previewCanvas.toDataURL('image/png')
+}
+
+export const lightenColor = (hex: string, amount: number): string => {
+  const clean = hex.replace('#', '')
+  if (clean.length !== 6) return hex
+  const num = parseInt(clean, 16)
+  const r = Math.min(255, (num >> 16) + amount)
+  const g = Math.min(255, ((num >> 8) & 0x00FF) + amount)
+  const b = Math.min(255, (num & 0x0000FF) + amount)
+  return `#${((r << 16) | (g << 8) | b).toString(16).padStart(6, '0')}`
+}
+
+export const hexToRgb = (hex: string): { r: number; g: number; b: number } => {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex)
+  return result ? {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16),
+  } : { r: 15, g: 23, b: 42 }
+}
+
+export const applyThemeStyles = (cfg: any): void => {
+  const theme = cfg.theme || 'dark'
+  const accentColor = cfg.accentColor || '#4f83e6'
+  const systemTextColor = cfg.systemTextColor || '#f8fafc'
+
+  document.documentElement.setAttribute('data-theme', theme)
+  document.documentElement.style.setProperty('--accent', accentColor)
+  document.documentElement.style.setProperty('--accent-hover', lightenColor(accentColor, 20))
+  document.documentElement.style.setProperty('--text-main', systemTextColor)
+  document.documentElement.style.setProperty('--glass-blur', cfg.glassBlur || 'blur(16px)')
+  document.body.style.fontFamily = cfg.fontFamily || "'Outfit', sans-serif"
+  document.documentElement.style.fontSize = cfg.fontSize || '18px'
+
+  if (theme === 'custom') {
+    if (cfg.customBgStart && cfg.customBgEnd) {
+      document.documentElement.style.setProperty('--bg-color', cfg.customBgStart)
+      document.documentElement.style.setProperty('--bg-gradient', `linear-gradient(135deg, ${cfg.customBgStart} 0%, ${cfg.customBgEnd} 100%)`)
+    }
+    if (cfg.customPanelBg) {
+      const rgb = hexToRgb(cfg.customPanelBg)
+      document.documentElement.style.setProperty('--panel-bg', `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, 0.75)`)
+      document.documentElement.style.setProperty('--panel-raised', `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, 0.82)`)
+      document.documentElement.style.setProperty('--panel-soft', `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, 0.46)`)
+      document.documentElement.style.setProperty('--chrome-bg', `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, 0.88)`)
+      document.documentElement.style.setProperty('--surface-bg', `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, 0.62)`)
+      document.documentElement.style.setProperty('--surface-strong', `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, 0.86)`)
+      document.documentElement.style.setProperty('--input-bg', `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, 0.72)`)
+    }
+    return
+  }
+
+  ;[
+    '--bg-color',
+    '--bg-gradient',
+    '--panel-bg',
+    '--panel-raised',
+    '--panel-soft',
+    '--chrome-bg',
+    '--surface-bg',
+    '--surface-strong',
+    '--input-bg',
+  ].forEach((prop) => document.documentElement.style.removeProperty(prop))
+}

package/src/renderer/src/agentProgress.ts

@@ -1,39 +1,11 @@
-import type { AgentProgress, InteractionMemory } from './tauri'
-
-export function thoughtsFrom(progress: AgentProgress[]): string[] {
-  return progress
-    .filter((event) => event.type === 'Thought')
-    .map((event) => (event as Extract<AgentProgress, { type: 'Thought' }>).data.thought)
-    .filter(Boolean)
-}
-
-export function trimAgentProgress(progress: AgentProgress[], maxNonThought = 20): AgentProgress[] {
-  if (progress.length === 0) return progress
-  const keptNonThought = new Set(
-    progress.filter((event) => event.type !== 'Thought').slice(-maxNonThought),
-  )
-  return progress.filter((event) => event.type === 'Thought' || keptNonThought.has(event))
-}
-
-export function hasAgentToolActivity(progress: AgentProgress[]): boolean {
-  return progress.some((event) => event.type === 'ToolStart' || event.type === 'ToolEnd')
-}
-
-export function mergeActivitySnapshots(
-  current: Record<string, AgentProgress[]>,
-  interactions: InteractionMemory[],
-): Record<string, AgentProgress[]> {
-  const merged = { ...current }
-  for (const interaction of interactions) {
-    const key = String(interaction.id)
-    if (interaction.agentActivity?.length && !merged[key]) {
-      merged[key] = interaction.agentActivity
-    }
-  }
-  return merged
-}
-
-export function parseAgentActivity(value: unknown): AgentProgress[] | undefined {
-  if (!Array.isArray(value)) return undefined
-  return value as AgentProgress[]
-}
+// Re-export everything from the shared module — do NOT add logic here.
+// Edit src/renderer/shared/agentProgress.ts instead.
+export type { AgentProgress, InteractionMemory } from '../shared/agentProgress'
+export {
+  thoughtsFrom,
+  trimAgentProgress,
+  hasAgentToolActivity,
+  mergeActivitySnapshots,
+  parseAgentActivity,
+  parseFileChangesFromProgress,
+} from '../shared/agentProgress'

package/src/renderer/src/calculator.ts

@@ -1,47 +1,4 @@
-export function evaluateArithmetic(source: string): number {
-  const tokens = source.replace(/\s+/g, '')
-  let index = 0
+// Re-export from the shared module — do NOT add logic here.
+// Edit src/renderer/shared/calculator.ts instead.
+export { evaluateArithmetic } from '../shared/calculator'
 
-  function parseExpression(): number {
-    let value = parseTerm()
-    while (tokens[index] === '+' || tokens[index] === '-') {
-      const operator = tokens[index++]
-      const right = parseTerm()
-      value = operator === '+' ? value + right : value - right
-    }
-    return value
-  }
-
-  function parseTerm(): number {
-    let value = parseFactor()
-    while (tokens[index] === '*' || tokens[index] === '/') {
-      const operator = tokens[index++]
-      const right = parseFactor()
-      value = operator === '*' ? value * right : value / right
-    }
-    return value
-  }
-
-  function parseFactor(): number {
-    if (tokens[index] === '+' || tokens[index] === '-') {
-      return tokens[index++] === '-' ? -parseFactor() : parseFactor()
-    }
-    if (tokens[index] === '(') {
-      index += 1
-      const value = parseExpression()
-      if (tokens[index++] !== ')') throw new Error('missing closing parenthesis')
-      return value
-    }
-    const match = tokens.slice(index).match(/^(?:\d+(?:\.\d*)?|\.\d+)/)
-    if (!match) throw new Error('expected a number')
-    index += match[0].length
-    return Number(match[0])
-  }
-
-  if (!tokens) throw new Error('expression is empty')
-  const result = parseExpression()
-  if (index !== tokens.length || !Number.isFinite(result)) {
-    throw new Error('invalid arithmetic expression')
-  }
-  return result
-}