@mazees/mark 5.0.0

package/src/renderer/src/hooks/agent/useMarkState.js

@@ -0,0 +1,173 @@
+import { useState, useEffect, useRef } from 'react'
+import { getAllConfig, saveMainThread, getMainThread } from '../../api/db'
+
+export const useMarkState = () => {
+  const [chatData, setChatData] = useState([])
+  const [config, setConfig] = useState([])
+  const [message, setMessage] = useState('')
+  const [isLoading, setIsLoading] = useState(false)
+  const [isAgentBusy, setIsAgentBusy] = useState(false)
+  const [runningSessionIds, setRunningSessionIds] = useState([])
+  const runningSessionId = runningSessionIds[0] || null
+
+  const addRunningSessionId = (id) => {
+    const num = Number(id)
+    setRunningSessionIds((prev) => (prev.map(Number).includes(num) ? prev : [...prev, num]))
+  }
+
+  const removeRunningSessionId = (id) => {
+    const num = Number(id)
+    setRunningSessionIds((prev) => prev.filter((x) => Number(x) !== num))
+  }
+
+  const setRunningSessionId = (id) => {
+    if (id === null || id === undefined) {
+      setRunningSessionIds([])
+    } else {
+      addRunningSessionId(id)
+    }
+  }
+  const [isSpeak, setIsSpeak] = useState(false)
+  const [orbStatus, setOrbStatus] = useState('idle')
+  const [currentResponse, setCurrentResponse] = useState(null)
+  const [notifications, setNotifications] = useState([])
+  const [activeProcesses, setActiveProcesses] = useState([])
+  const [inputSource, setInputSource] = useState('pc')
+  const [activeTopic, setActiveTopic] = useState(null)
+  const [currentActiveSessionId, setCurrentActiveSessionId] = useState('1')
+  const [isChatLoaded, setIsChatLoaded] = useState(false)
+  const [isBooting, setIsBooting] = useState(true)
+  const sessionId = useRef('mark-main-thread')
+
+  const abortControllerRef = useRef(null)
+
+  const loadConfig = async () => {
+    const data = await getAllConfig()
+    if (data.length > 0) setConfig(data)
+  }
+
+  useEffect(() => {
+    loadConfig()
+    loadMainThread()
+
+    const handleConfigUpdate = (e) => {
+      if (e.detail) {
+        setConfig([e.detail])
+      }
+    }
+
+    const handleAiReset = () => {
+      setChatData([])
+      setCurrentActiveSessionId('1')
+      setActiveTopic(null)
+      setCurrentResponse(null)
+      setNotifications([])
+      setActiveProcesses([])
+    }
+
+    window.addEventListener('config-updated', handleConfigUpdate)
+    window.addEventListener('ai-reset-complete', handleAiReset)
+    return () => {
+      window.removeEventListener('config-updated', handleConfigUpdate)
+      window.removeEventListener('ai-reset-complete', handleAiReset)
+    }
+  }, [])
+
+  const loadMainThread = async () => {
+    const data = await getMainThread()
+    if (data && data.length > 0) {
+      setChatData(data)
+    }
+    setIsChatLoaded(true)
+  }
+
+  useEffect(() => {
+    // Debounce simpan ke DB agar tidak membanjiri SQLite REST endpoint saat streaming token
+    if (chatData !== undefined && isChatLoaded) {
+      const timer = setTimeout(() => {
+        saveMainThread(chatData)
+      }, 800)
+      return () => clearTimeout(timer)
+    }
+  }, [chatData, isChatLoaded])
+
+  const clearChat = () => {
+    setChatData([]) // saveMainThread will auto save the empty array
+  }
+
+  const pushNotification = (type, message) => {
+    setNotifications((prev) => [
+      ...prev,
+      { id: Date.now() + Math.random(), type, message, timestamp: Date.now() }
+    ])
+  }
+
+  const pushProcess = (process) => {
+    // process: { id, type, status, data }
+    setActiveProcesses((prev) => {
+      const existing = prev.findIndex((p) => p.id === process.id)
+      if (existing !== -1) {
+        // Update
+        const next = [...prev]
+        next[existing] = { ...next[existing], ...process }
+        return next
+      }
+      // Add new
+      return [...prev, process]
+    })
+  }
+
+  const dismissProcess = (id) => {
+    setActiveProcesses((prev) => prev.filter((p) => p.id !== id))
+  }
+
+  const handleStop = () => {
+    abortControllerRef.current?.abort()
+    if (window.api?.browserClose) {
+      window.api.browserClose()
+    }
+  }
+
+  return {
+    chatData,
+    setChatData,
+    sessionId: sessionId.current,
+    config,
+    setConfig,
+    message,
+    setMessage,
+    isLoading,
+    setIsLoading,
+    isAgentBusy,
+    setIsAgentBusy,
+    runningSessionId,
+    setRunningSessionId,
+    runningSessionIds,
+    setRunningSessionIds,
+    addRunningSessionId,
+    removeRunningSessionId,
+    isSpeak,
+    setIsSpeak,
+    orbStatus,
+    setOrbStatus,
+    currentResponse,
+    setCurrentResponse,
+    notifications,
+    pushNotification,
+    activeProcesses,
+    setActiveProcesses,
+    pushProcess,
+    dismissProcess,
+    inputSource,
+    setInputSource,
+    activeTopic,
+    setActiveTopic,
+    currentActiveSessionId,
+    setCurrentActiveSessionId,
+    isChatLoaded,
+    isBooting,
+    setIsBooting,
+    abortControllerRef,
+    handleStop
+  }
+}

package/src/renderer/src/hooks/agent/useMarkYoutube.js

@@ -0,0 +1,82 @@
+import axios from 'axios'
+import { getYoutubeSummary } from '../../api/ai/tools'
+
+export const useMarkYoutube = (setChatData) => {
+  const handleYoutubeSearch = async (answer, signal, customSetChatData) => {
+    const targetSet = customSetChatData || setChatData
+    try {
+      const searchResults = await window.api.searchYoutube(answer.command.query)
+      targetSet((prev) => [
+        ...prev.filter((item) => !item.isThinking),
+        {
+          role: 'ai',
+          content: answer.answer,
+          isYoutubeSearch: true,
+          youtubeLink: [...searchResults],
+          queryYoutube: answer.command.query
+        }
+      ])
+    } catch (error) {
+      console.error('Youtube Search Error:', error)
+      if (error.name === 'AbortError') {
+        targetSet((prev) => [...prev.filter((item) => !item.isThinking)])
+        targetSet((prev) => prev.slice(0, -1))
+      } else {
+        targetSet((prev) => [
+          ...prev.filter((item) => !item.isThinking),
+          {
+            role: 'ai',
+            content: 'Gagal dapet info dari youtube nih, koneksi atau captcha mungkin bermasalah.'
+          }
+        ])
+      }
+    }
+  }
+
+  const getYoutubeData = async (url) => {
+    try {
+      const endpoint = `https://www.youtube.com/embed?url=${encodeURIComponent(url)}&format=json`
+      const response = await axios.get(endpoint)
+      const data = response.data
+      return {
+        judul: data.title,
+        author: data.author_name,
+        thumbnail: data.thumbnail_url,
+        success: true
+      }
+    } catch (error) {
+      console.error('Gagal ambil data YouTube:', error.message)
+      return { judul: 'Video Tidak Ditemukan', author: '-', thumbnail: null, success: false }
+    }
+  }
+
+  const handleYoutubeSummary = async (url, signal, customSetChatData) => {
+    const targetSet = customSetChatData || setChatData
+    targetSet((prev) => [...prev, { role: 'ai', content: 'Sedang menonton video youtube (hal ini akan membutuhkan waktu beberapa saat mohon ditunggu)...', isSummarizing: true, youtubeLink: url }])
+    try {
+      const data = await getYoutubeData(url)
+      const searchResults = await getYoutubeSummary(url, data, signal)
+      targetSet((prev) => [
+        ...prev.filter((item) => !item.isSummarizing),
+        { role: 'ai', content: searchResults, isYoutubeSummary: true, youtubeLink: url }
+      ])
+    } catch (error) {
+      console.error('Youtube Summary Error:', error)
+      if (error.name === 'AbortError') {
+        targetSet((prev) => [...prev.filter((item) => !item.isSummarizing)])
+        targetSet((prev) => prev.slice(0, -1))
+      } else {
+        targetSet((prev) => [
+          ...prev.filter((item) => !item.isSummarizing),
+          {
+            role: 'ai',
+            content: 'Gagal dapet info dari youtube nih, koneksi atau captcha mungkin bermasalah.'
+          }
+        ])
+      }
+    }
+  }
+
+
+  return { handleYoutubeSearch, handleYoutubeSummary, getYoutubeData }
+}

package/src/renderer/src/hooks/agent/useRelationalGrowth.js

@@ -0,0 +1,201 @@
+import { useEffect, useRef } from 'react'
+import { getRelationship, saveRelationship, insertMemory, normalizeDbId } from '../../api/db'
+import { evaluateTraitDrift } from '../../api/ai/relationship'
+
+export const useRelationalGrowth = ({
+  chatData,
+  currentActiveSessionId = '1',
+  isLoading = false
+}) => {
+  const lastEvalChatLenRef = useRef(0)
+
+  // --- RELATIONAL GROWTH EVALUATION (Event-Based) ---
+  useEffect(() => {
+    // Evaluasi hubungan emosi HANYA dilakukan di sesi utama ('1') dan saat turn chat selesai (tidak sedang loading)
+    if (normalizeDbId(currentActiveSessionId) !== '1' || isLoading) {
+      return
+    }
+
+    const evaluateGrowth = async () => {
+      try {
+        const allCleanChats = (chatData || []).filter(
+          (m) => !m.isThinking && !m.isSearching && !m.isSummarizing
+        )
+        const currentCleanLen = allCleanChats.length
+        if (currentCleanLen === 0) return
+
+        // Initialize state dari database saat pertama kali jalan
+        const oldTraits = await getRelationship('owner')
+        const dbLastIndex = oldTraits.lastChatIndex ?? oldTraits.last_chat_index ?? 0
+
+        if (lastEvalChatLenRef.current === 0) {
+          // Jika dbLastIndex belum diset (0) atau melebihi jumlah chat saat ini (karena prune/archive),
+          // set baseline awal ke currentCleanLen saat ini
+          if (dbLastIndex === 0 || dbLastIndex > currentCleanLen) {
+            lastEvalChatLenRef.current = currentCleanLen
+            await saveRelationship({
+              userId: 'owner',
+              ...oldTraits,
+              lastChatIndex: currentCleanLen,
+              last_chat_index: currentCleanLen
+            })
+          } else {
+            lastEvalChatLenRef.current = dbLastIndex
+          }
+        }
+
+        // Jika chat pernah dibersihkan/dipangkas sehingga lebih kecil dari baseline sebelumnya
+        if (currentCleanLen < lastEvalChatLenRef.current) {
+          lastEvalChatLenRef.current = currentCleanLen
+          await saveRelationship({
+            userId: 'owner',
+            ...oldTraits,
+            lastChatIndex: currentCleanLen,
+            last_chat_index: currentCleanLen
+          })
+          return
+        }
+
+        // Trigger evaluasi setiap selisih 15 pesan
+        if (currentCleanLen - lastEvalChatLenRef.current >= 15) {
+          console.log(
+            '[Relational Growth] Threshold 15 chat tercapai di sesi utama. Mengevaluasi mood...'
+          )
+
+          // Batasi maksimal 20 pesan terbaru dan batasi panjang teks per pesan
+          const startIndex = Math.max(lastEvalChatLenRef.current, currentCleanLen - 20)
+          const recentForEval = allCleanChats
+            .slice(startIndex)
+            .map((m) => {
+              let timeStr = ''
+              if (m.timestamp) {
+                timeStr =
+                  typeof m.timestamp === 'number'
+                    ? `[${new Date(m.timestamp).toLocaleString('id-ID')}] `
+                    : `[${m.timestamp}] `
+              }
+              const rawContent =
+                typeof m.content === 'string'
+                  ? m.content
+                  : m.content
+                    ? JSON.stringify(m.content)
+                    : ''
+              const safeContent =
+                rawContent.length > 500 ? `${rawContent.slice(0, 500)}... [dipotong]` : rawContent
+              return `${timeStr}${m.role === 'user' ? 'User' : 'Mark'}: ${safeContent}`
+            })
+            .join('\n')
+
+          // Simpan state panjang chat saat ini untuk evaluasi berikutnya
+          lastEvalChatLenRef.current = currentCleanLen
+
+          // Evaluasi AI
+          const newTraits = await evaluateTraitDrift(oldTraits, recentForEval, 'owner')
+          console.log('[Relational Growth] Trait shift:', newTraits)
+
+          // Simpan trait baru ke database
+          const updatedRecord = {
+            userId: 'owner',
+            ...newTraits,
+            lastEvaluation: new Date().toISOString(),
+            evalCount: (oldTraits.evalCount || 0) + 1,
+            lastChatIndex: currentCleanLen,
+            last_chat_index: currentCleanLen
+          }
+          await saveRelationship(updatedRecord)
+
+          window.dispatchEvent(
+            new CustomEvent('relationship-updated', {
+              detail: updatedRecord
+            })
+          )
+
+          // Simpan relational memory jika AI merasa ada hal penting
+          if (newTraits.new_relational_memory) {
+            await insertMemory({
+              type: 'notes',
+              summary: '[Relational] Catatan hubungan otomatis',
+              memory: newTraits.new_relational_memory
+            })
+            console.log(
+              '[Relational Growth] Relational memory tersimpan:',
+              newTraits.new_relational_memory
+            )
+          }
+        }
+      } catch (err) {
+        console.error('[Relational Growth] Gagal mengevaluasi hubungan:', err)
+      }
+    }
+
+    evaluateGrowth()
+  }, [chatData, currentActiveSessionId, isLoading])
+
+  // Listener untuk evaluasi relasi berbasis event (misal dari Private Journal / akhir sesi)
+  useEffect(() => {
+    const handleForceRelationalEval = async (e) => {
+      try {
+        const oldTraits = await getRelationship('owner')
+        const contextText =
+          e.detail?.summary || 'Sesi kerja panjang dan refleksi batin harian bersama pengguna.'
+        const newTraits = await evaluateTraitDrift(oldTraits, contextText, 'owner')
+        const updatedRecord = {
+          userId: 'owner',
+          ...newTraits,
+          lastEvaluation: new Date().toISOString(),
+          evalCount: (oldTraits.evalCount || 0) + 1
+        }
+        await saveRelationship(updatedRecord)
+        window.dispatchEvent(
+          new CustomEvent('relationship-updated', {
+            detail: updatedRecord
+          })
+        )
+        if (newTraits.new_relational_memory) {
+          await insertMemory({
+            type: 'notes',
+            summary: '[Relational] Catatan hubungan otomatis',
+            memory: newTraits.new_relational_memory
+          })
+        }
+      } catch (err) {
+        console.warn('[Relational Growth] Gagal evaluasi relasi dari event:', err)
+      }
+    }
+    window.addEventListener('mark:evaluate-relationship', handleForceRelationalEval)
+    return () => window.removeEventListener('mark:evaluate-relationship', handleForceRelationalEval)
+  }, [])
+
+  // --- TACTILE INTERACTION DRIFT (Touch, Pet, Bonk) ---
+  useEffect(() => {
+    const handleTactile = async (e) => {
+      const type = e.detail?.type
+      if (!type) return
+      try {
+        const current = await getRelationship('owner')
+        let { warmth = 0.5, trust = 0.5, sarcasm_level = 0.5 } = current || {}
+        if (type === 'petting' || type === 'pet_purr') {
+          warmth = Math.min(1.0, warmth + 0.005)
+          trust = Math.min(1.0, trust + 0.005)
+        } else if (type === 'bonk_annoyed') {
+          sarcasm_level = Math.min(1.0, sarcasm_level + 0.005)
+        } else if (type === 'bonk_dizzy' || type === 'shield_block') {
+          sarcasm_level = Math.min(1.0, sarcasm_level + 0.01)
+          trust = Math.max(0.15, trust - 0.005)
+        }
+        const updatedRecord = {
+          ...current,
+          userId: 'owner',
+          warmth,
+          trust,
+          sarcasm_level,
+          lastEvaluation: new Date().toISOString()
+        }
+        await saveRelationship(updatedRecord)
+        window.dispatchEvent(new CustomEvent('relationship-updated', { detail: updatedRecord }))
+      } catch (_) {}
+    }
+    window.addEventListener('mark-tactile-interaction', handleTactile)
+    return () => window.removeEventListener('mark-tactile-interaction', handleTactile)
+  }, [])
+}

package/src/renderer/src/hooks/telegram/useTelegramBot.js

@@ -0,0 +1,63 @@
+import { useState, useEffect } from 'react'
+import { webApi } from '../../api/web-bridge'
+
+export const useTelegramBot = () => {
+  const [status, setStatus] = useState('disconnected')
+  const [messages, setMessages] = useState([])
+  const [isThinking, setIsThinking] = useState(false)
+  const [currentSender, setCurrentSender] = useState('')
+
+  useEffect(() => {
+    webApi.tgGetStatus().then((res) => {
+      if (res?.status) setStatus(res.status)
+    })
+
+    webApi.tgGetHistory().then((history) => {
+      if (history && history.length > 0) {
+        setMessages(history)
+      }
+    })
+
+    const unsubConn = webApi.onTgConnection((newStatus) => {
+      setStatus(newStatus)
+    })
+
+    const unsubThink = webApi.onTgThinking(({ sender }) => {
+      setIsThinking(true)
+      setCurrentSender(sender)
+    })
+
+    const unsubMsg = webApi.onTgMessage((data) => {
+      setMessages((prev) => [...prev, { type: 'incoming', ...data }])
+    })
+
+    const unsubReply = webApi.onTgReplySent((data) => {
+      setMessages((prev) => [...prev, { type: 'outgoing', ...data }])
+      setIsThinking(false)
+    })
+
+    return () => {
+      if (typeof unsubConn === 'function') unsubConn()
+      if (typeof unsubThink === 'function') unsubThink()
+      if (typeof unsubMsg === 'function') unsubMsg()
+      if (typeof unsubReply === 'function') unsubReply()
+    }
+  }, [])
+
+  const startBot = (token) => {
+    webApi.tgStart(token)
+  }
+
+  const stopBot = () => {
+    webApi.tgStop()
+  }
+
+  return {
+    status,
+    messages,
+    isThinking,
+    currentSender,
+    startBot,
+    stopBot
+  }
+}