@mazees/mark 5.0.0

package/src/renderer/src/api/tools/index.js

@@ -0,0 +1,151 @@
+import { core_tools, core_tools_schema } from './core-tools'
+import { webApi } from '../web-bridge.js'
+
+let cachedGroupToolsFlat = {}
+let cachedGroupToolsSchema = {}
+let cachedGroupToolNames = []
+
+// Inisialisasi cache secara background agar checkTools siap sedini mungkin
+if (typeof window !== 'undefined') {
+  webApi
+    .getGroupTools()
+    .then((data) => {
+      if (data?.flat) cachedGroupToolsFlat = data.flat
+      if (data?.schema) cachedGroupToolsSchema = data.schema
+      if (data?.names) cachedGroupToolNames = data.names
+    })
+    .catch(() => {})
+}
+
+export const checkTools = (toolName) => {
+  return (
+    !!core_tools[toolName] ||
+    !!cachedGroupToolsFlat[toolName] ||
+    toolName === 'read-tools' ||
+    (typeof toolName === 'string' && toolName.startsWith('plugin-'))
+  )
+}
+
+/**
+ * Mengambil array skema tools OpenAPI lengkap untuk dikirimkan ke model.
+ * Menyaring tool groups yang relevan dengan query atau yang telah dimuat via 'read-tools' untuk menghemat context window.
+ * @param {string} _intentQuery Kata kunci / prompt user (disimpan untuk kompatibilitas filter)
+ * @param {Set<string>|Array<string>} loadedGroups Daftar nama group yang telah dimuat via read-tools
+ */
+export const getActiveToolsSchema = async (intentQuery = '', loadedGroups = []) => {
+  void intentQuery
+  const groupToolsData = await webApi.getGroupTools()
+  const groupToolsSchema = groupToolsData?.schema || cachedGroupToolsSchema || {}
+  const groupToolGroupNames = groupToolsData?.names || cachedGroupToolNames || []
+  if (groupToolsData?.flat) cachedGroupToolsFlat = groupToolsData.flat
+
+  const activeSchemas = [...core_tools_schema]
+  const seenToolNames = new Set(core_tools_schema.map((t) => t.function?.name))
+  const loadedSet = loadedGroups instanceof Set ? loadedGroups : new Set(loadedGroups || [])
+
+  for (const [groupKey, group] of Object.entries(groupToolsSchema)) {
+    // Hanya tambah schema group jika user explicit panggil read-tools("group_name")
+    if (loadedSet.has(groupKey) && Array.isArray(group.tools)) {
+      for (const t of group.tools) {
+        const name = t.function?.name
+        if (name && !seenToolNames.has(name)) {
+          seenToolNames.add(name)
+          activeSchemas.push(t)
+        }
+      }
+    }
+  }
+
+  // Muat dynamic plugin actions jika group plugin aktif tersebut telah dimuat via read-tools
+  let activePluginNames = []
+  try {
+    if (typeof window !== 'undefined' && window.api && window.api.getPlugins) {
+      const plugins = await window.api.getPlugins()
+      if (Array.isArray(plugins)) {
+        const activePlugins = plugins.filter((p) => p.isEnabled !== false)
+        activePluginNames = activePlugins.map((p) => p.name)
+
+        for (const plugin of activePlugins) {
+          if (
+            (loadedSet.has(plugin.name) || loadedSet.has('custom_plugins')) &&
+            Array.isArray(plugin.actions)
+          ) {
+            for (const act of plugin.actions) {
+              const pName = `plugin-${plugin.name}-${act.name}`
+              if (!seenToolNames.has(pName)) {
+                seenToolNames.add(pName)
+                activeSchemas.push({
+                  type: 'function',
+                  function: {
+                    name: pName,
+                    description: `[Plugin: ${plugin.name}] ${act.description || act.triggerHint || ''}`,
+                    parameters: {
+                      type: 'object',
+                      properties: {
+                        query: { type: 'string', description: 'Parameter aksi plugin' }
+                      },
+                      required: ['query'],
+                      additionalProperties: false
+                    }
+                  }
+                })
+              }
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  // Perbarui parameter enum dan description pada read-tools agar mencakup nama plugin aktif
+  const readToolsIdx = activeSchemas.findIndex((s) => s.function?.name === 'read-tools')
+  if (readToolsIdx >= 0) {
+    const orig = activeSchemas[readToolsIdx]
+    const allGroups = [...groupToolGroupNames, ...activePluginNames]
+    activeSchemas[readToolsIdx] = {
+      ...orig,
+      function: {
+        ...orig.function,
+        parameters: {
+          ...orig.function?.parameters,
+          properties: {
+            ...orig.function?.parameters?.properties,
+            group_name: {
+              type: 'string',
+              description: `Nama grup tool bawaan atau plugin aktif: ${allGroups.join(', ')}`,
+              enum: allGroups
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Pastikan seluruh schema tool memiliki parameter reason wajib
+  for (const t of activeSchemas) {
+    if (t.function?.parameters?.properties) {
+      if (!t.function.parameters.properties.reason) {
+        t.function.parameters.properties.reason = {
+          type: 'string',
+          description:
+            'Penjelasan ringkas dalam bahasa manusia mengenai alasan atau tujuan aksi ini (contoh: "Membuka tab Instagram di browser").'
+        }
+      }
+      if (Array.isArray(t.function.parameters.required)) {
+        if (!t.function.parameters.required.includes('reason')) {
+          t.function.parameters.required.push('reason')
+        }
+      } else {
+        t.function.parameters.required = ['reason']
+      }
+    }
+  }
+
+  return activeSchemas
+}
+
+export const getGroupTools = () => webApi.getGroupTools()
+
+export { core_tools, core_tools_schema }

package/src/renderer/src/api/turnPairMigrator.js

@@ -0,0 +1,200 @@
+import { generateVector } from './vectorMemory'
+import {
+  getAllSessions,
+  saveBatchChatTurns,
+  saveChatTurn
+} from './db'
+import { insertBatchTurnPairsToOrama, insertTurnPairToOrama } from './oramaStore'
+
+/**
+ * Ekstraksi teks murni dari objek pesan (mendukung string biasa atau array multimodal)
+ */
+function cleanMessageContent(content) {
+  if (typeof content === 'string') return content.trim()
+  if (Array.isArray(content)) {
+    const textPart = content.find((c) => c.type === 'text')
+    return textPart?.text ? textPart.text.trim() : ''
+  }
+  if (content && typeof content === 'object' && content.text) {
+    return String(content.text).trim()
+  }
+  return ''
+}
+
+function normalizeTimestamp(ts) {
+  if (typeof ts === 'number' && !isNaN(ts)) return ts
+  if (typeof ts === 'string') {
+    const parsed = Date.parse(ts)
+    if (!isNaN(parsed)) return parsed
+    const num = Number(ts)
+    if (!isNaN(num)) return num
+  }
+  return Date.now()
+}
+
+/**
+ * Memetakan riwayat pesan satu sesi menjadi array Turn Pairs (Tanya - Jawab)
+ */
+export function extractTurnPairsFromSession(sessionData, sessionId, sessionTitle) {
+  const pairs = []
+  if (!Array.isArray(sessionData) || sessionData.length === 0) return pairs
+
+  const cleanTitle = sessionTitle || `Session ${sessionId}`
+
+  for (let i = 0; i < sessionData.length; i++) {
+    const msg = sessionData[i]
+    if (!msg) continue
+
+    // Abaikan pesan intermediate / thinking / searching
+    if (msg.isThinking || msg.isSearching || msg.isSummarizing) continue
+
+    if (msg.role === 'user') {
+      const userText = cleanMessageContent(msg.content)
+      if (!userText || userText.length < 2) continue
+
+      // Cari balasan AI yang sesuai setelah pesan user ini
+      let aiText = ''
+      let aiMsgTimestamp = null
+
+      for (let j = i + 1; j < sessionData.length; j++) {
+        const nextMsg = sessionData[j]
+        if (!nextMsg) continue
+        if (nextMsg.role === 'user') break // Berhenti jika sudah bertemu pesan user berikutnya
+        if (nextMsg.role === 'ai' && !nextMsg.isThinking && !nextMsg.isSearching && !nextMsg.isSummarizing) {
+          aiText = cleanMessageContent(nextMsg.content)
+          aiMsgTimestamp = nextMsg.timestamp
+          break
+        }
+      }
+
+      // Pastikan ada konten yang bermakna
+      if (userText.length > 2 || aiText.length > 2) {
+        const rawTs = msg.timestamp || aiMsgTimestamp || Date.now()
+        const timestamp = normalizeTimestamp(rawTs)
+        const pairId = `turn-${sessionId}-${timestamp}-${i}`
+        const combinedText = `[User]: ${userText}\n[Mark]: ${aiText || '(Menjalankan instruksi)'}`
+
+        pairs.push({
+          pairId,
+          sessionId: Number(sessionId),
+          sessionTitle: cleanTitle,
+          userText,
+          aiText,
+          combinedText,
+          timestamp
+        })
+      }
+    }
+  }
+
+  return pairs
+}
+
+/**
+ * Migrasi bertahap data chat lama ke dalam format Turn-Pair Vektor (Smart Incremental Queue)
+ */
+export async function migrateOldSessionsToTurns(onProgress) {
+  try {
+    const sessions = await getAllSessions()
+    if (!Array.isArray(sessions) || sessions.length === 0) return 0
+
+    // Kumpulkan seluruh turn pair dari semua sesi
+    const allPairs = []
+    for (const session of sessions) {
+      const turns = extractTurnPairsFromSession(session.data, session.id, session.title)
+      allPairs.push(...turns)
+    }
+
+    const totalCount = allPairs.length
+    if (totalCount === 0) return 0
+
+    console.log(`[TurnMigrator] Memulai migrasi ${totalCount} turn pairs lama...`)
+    if (typeof onProgress === 'function') {
+      onProgress(0, totalCount)
+    }
+
+    const BATCH_SIZE = 5
+    let processedCount = 0
+
+    for (let i = 0; i < allPairs.length; i += BATCH_SIZE) {
+      const batch = allPairs.slice(i, i + BATCH_SIZE)
+      const validTurns = []
+
+      for (const turn of batch) {
+        try {
+          const vector = await generateVector(turn.combinedText)
+          if (vector && vector.length === 384) {
+            validTurns.push({
+              ...turn,
+              vector
+            })
+          }
+        } catch (err) {
+          console.warn(`[TurnMigrator] Gagal generate vector untuk turn ${turn.pairId}:`, err)
+        }
+      }
+
+      if (validTurns.length > 0) {
+        await saveBatchChatTurns(validTurns)
+        await insertBatchTurnPairsToOrama(validTurns)
+      }
+
+      processedCount += batch.length
+      if (typeof onProgress === 'function') {
+        onProgress(Math.min(processedCount, totalCount), totalCount)
+      }
+
+      // Jeda istirahat CPU (60ms) agar event loop tetap responsif
+      await new Promise((resolve) => setTimeout(resolve, 60))
+    }
+
+    console.log(`[TurnMigrator] Sukses menyelesaikan migrasi ${totalCount} turn pairs!`)
+    return totalCount
+  } catch (error) {
+    console.error('[TurnMigrator] Error saat migrasi sessions to turns:', error)
+    return 0
+  }
+}
+
+/**
+ * Pengindeksan instan 1 pasang percakapan secara real-time saat chat selesai
+ */
+export async function indexSingleTurn(sessionId, sessionTitle, userMsg, aiMsg) {
+  try {
+    const userText = cleanMessageContent(userMsg?.content || userMsg)
+    const aiText = cleanMessageContent(aiMsg?.content || aiMsg)
+
+    if (!userText && !aiText) return null
+    if (userText.length < 2 && aiText.length < 2) return null
+
+    const timestamp = Date.now()
+    const pairId = `turn-${sessionId}-${timestamp}`
+    const combinedText = `[User]: ${userText}\n[Mark]: ${aiText || '(Menjalankan instruksi)'}`
+
+    const vector = await generateVector(combinedText)
+    if (!vector || vector.length !== 384) {
+      console.warn('[TurnMigrator] Gagal generate vector untuk turn baru')
+      return null
+    }
+
+    const turnData = {
+      pairId,
+      sessionId: Number(sessionId) || 1,
+      sessionTitle: sessionTitle || 'Main Thread',
+      userText,
+      aiText,
+      combinedText,
+      timestamp,
+      vector
+    }
+
+    await saveChatTurn(turnData)
+    await insertTurnPairToOrama(turnData)
+
+    console.log(`[TurnMigrator] Realtime indexed turn pair: ${pairId}`)
+    return turnData
+  } catch (err) {
+    console.error('[TurnMigrator] Error indexSingleTurn:', err)
+    return null
+  }
+}

package/src/renderer/src/api/vectorMemory.js

@@ -0,0 +1,136 @@
+import {
+  searchArchives,
+  searchDocuments,
+  searchMemoriesInOrama,
+  searchTurnPairsInOrama
+} from './oramaStore'
+import { getAllMemory } from './db'
+import { API_BASE } from './web-bridge'
+
+export const getExtractor = async () => {
+  return true
+}
+
+export const generateVector = async (text) => {
+  if (!text || typeof text !== 'string' || !text.trim()) {
+    return null
+  }
+
+  try {
+    const res = await fetch(`${API_BASE}/api/vector`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ text })
+    })
+    const json = await res.json()
+    return json.vector || null
+  } catch (error) {
+    console.error('Gagal generate vector via server API:', error)
+    return null
+  }
+}
+
+// SEARCH: Rumus matematika buat ngukur kemiripan (0 sampai 1)
+export const cosineSimilarity = (vecA, vecB) => {
+  if (!Array.isArray(vecA) || !Array.isArray(vecB) || vecA.length === 0 || vecB.length === 0) {
+    return 0
+  }
+
+  return vecA.reduce((sum, a, i) => sum + a * vecB[i], 0)
+}
+
+export const getRelevantMemory = async (userInput, memoryList) => {
+  let list = memoryList
+  if (!Array.isArray(list)) {
+    try {
+      list = await getAllMemory()
+    } catch (e) {
+      list = []
+    }
+  }
+  if (!Array.isArray(list)) {
+    list = []
+  }
+  const coreMemories = list
+    .filter((m) => m && typeof m === 'object' && (m.type === 'profile' || m.type === 'preference'))
+    .map(({ vector, ...rest }) => rest)
+
+  return coreMemories
+}
+
+export const searchExtendedMemory = async (query, threshold = 0.5, limit = 5) => {
+  const queryVector = await generateVector(query)
+  if (!queryVector) return { memories: [], chatTurns: [] }
+
+  const memories = await searchMemoriesInOrama(
+    query,
+    queryVector,
+    limit,
+    ['notes', 'learn'],
+    threshold
+  )
+  const chatTurns = await searchTurnPairsInOrama(query, queryVector, limit, threshold)
+
+  return { memories, chatTurns }
+}
+
+export const executeMemorySearch = async (rawQuery) => {
+  const parts = (rawQuery || '').split('||')
+  const searchKeyword = parts[0]?.trim() || ''
+  const customThreshold =
+    parts[1] && !isNaN(parseFloat(parts[1])) ? parseFloat(parts[1].trim()) : 0.5
+  const customLimit = parts[2] && !isNaN(parseInt(parts[2], 10)) ? parseInt(parts[2].trim(), 10) : 5
+
+  const { memories = [], chatTurns = [] } = await searchExtendedMemory(
+    searchKeyword,
+    customThreshold,
+    customLimit
+  )
+
+  const formattedMemories =
+    memories.length > 0
+      ? memories
+          .map(
+            (m) =>
+              `- [${m.type.toUpperCase()}] (ID:${m.id}, Score:${(m.score || 0).toFixed(2)}) ${m.memory}`
+          )
+          .join('\n')
+      : ''
+
+  const formattedTurns =
+    chatTurns.length > 0
+      ? chatTurns
+          .map(
+            (t) =>
+              `--- [RIWAYAT CHAT: "${t.sessionTitle || 'Session'}" | Score:${(t.score || 0).toFixed(2)}] ---\n${t.combinedText}`
+          )
+          .join('\n\n')
+      : ''
+
+  let sections = []
+  if (formattedMemories) {
+    sections.push(`[CATATAN & MEMORI PENGGUNA]\n${formattedMemories}`)
+  }
+  if (formattedTurns) {
+    sections.push(`[RIWAYAT PERCAKAPAN ASLI (TURN PAIRS)]\n${formattedTurns}`)
+  }
+
+  if (sections.length > 0) {
+    return `[MEMORY SEARCH RESULTS (Threshold: ${customThreshold}, Limit: ${customLimit})]\n\n${sections.join('\n\n')}`
+  }
+  return `[MEMORY SEARCH RESULTS (Threshold: ${customThreshold}, Limit: ${customLimit})]\nTidak ditemukan memori atau percakapan yang relevan dengan kata kunci "${searchKeyword}".`
+}
+
+export const getUnifiedContext = async (userInput, memoryList) => {
+  const memories = await getRelevantMemory(userInput, memoryList)
+
+  const output = await generateVector(userInput)
+  if (!output) return { memories, archives: [], documents: [], turnPairs: [] }
+  const userVector = Array.from(output)
+
+  const archives = await searchArchives(userVector, 3)
+  const documents = await searchDocuments(userInput, userVector, 5)
+  const turnPairs = await searchTurnPairsInOrama(userInput, userVector, 3, 0.3)
+
+  return { memories, archives, documents, turnPairs }
+}

package/src/renderer/src/api/wakeWord.js

@@ -0,0 +1,101 @@
+// Wake Word Engine Pattern Matcher & Command Extractor
+// Mendukung pola default "Hey Mark", "Halo Mark", "Mark" serta kata pemicu kustom pengguna
+
+// Pola kata Mark dan variasinya dalam pengenalan suara bahasa Indonesia Edge STT
+const DEFAULT_MARK_NAMES = '(?:mark|marc|mak|mart|marg|makh|smart|marck)'
+const GREETINGS = '(?:hey|hei|halo|hello|helo|hai|hi|woi|oi|bro)'
+
+/**
+ * Membuat Regex matcher dinamis dari kata pemicu default + custom wake words
+ */
+export function getWakeWordRegex(customWakeWords = '') {
+  const parts = [DEFAULT_MARK_NAMES]
+
+  if (customWakeWords) {
+    const rawList = Array.isArray(customWakeWords)
+      ? customWakeWords
+      : String(customWakeWords).split(/[,|\n]+/)
+
+    for (const item of rawList) {
+      const clean = item.trim()
+      if (clean) {
+        const escaped = clean.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        parts.push(escaped)
+      }
+    }
+  }
+
+  const combinedNames = `(?:${parts.join('|')})`
+  return new RegExp(`(?:\\b${GREETINGS}[,\\s]+)?\\b${combinedNames}\\b`, 'i')
+}
+
+/**
+ * Mendeteksi keberadaan wake word dalam teks transkrip dan memisahkan perintah
+ */
+export function detectWakeWord(transcript, customWakeWords = '') {
+  if (!transcript || typeof transcript !== 'string') {
+    return { detected: false, command: '', wakePhrase: '' }
+  }
+
+  const regex = getWakeWordRegex(customWakeWords)
+  const match = transcript.match(regex)
+
+  if (!match) {
+    return { detected: false, command: '', wakePhrase: '' }
+  }
+
+  const wakePhrase = match[0]
+  const matchIndex = match.index
+  const matchLength = match[0].length
+
+  // Ambil teks setelah kata pemicu (jika user langsung mengucapkan perintah dalam 1 tarikan napas)
+  const afterWakeText = transcript.substring(matchIndex + matchLength).trim()
+
+  // Bersihkan tanda baca awal seperti koma, titik dua, tanda hubung
+  const cleanCommand = cleanSpokenCommand(afterWakeText, customWakeWords)
+
+  return {
+    detected: true,
+    wakePhrase,
+    command: cleanCommand
+  }
+}
+
+/**
+ * Membersihkan awalan sapaan / nama pemicu dari perintah yang diucapkan
+ */
+export function cleanSpokenCommand(text, customWakeWords = '') {
+  if (!text || typeof text !== 'string') return ''
+
+  const parts = [DEFAULT_MARK_NAMES]
+
+  if (customWakeWords) {
+    const rawList = Array.isArray(customWakeWords)
+      ? customWakeWords
+      : String(customWakeWords).split(/[,|\n]+/)
+
+    for (const item of rawList) {
+      const clean = item.trim()
+      if (clean) {
+        const escaped = clean.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        parts.push(escaped)
+      }
+    }
+  }
+
+  const combinedNames = `(?:${parts.join('|')})`
+  const prefixRegex = new RegExp(`^\\s*(?:${GREETINGS}[,\\s]+)?${combinedNames}\\b`, 'gi')
+
+  let stripped = text
+    .replace(/^[,.:;!\-–—\s]+/, '')
+    .replace(prefixRegex, '')
+    .replace(/^[,.:;!\-–—\s]+/, '')
+    .trim()
+
+  // Jika setelah dibersihkan hanya berisi tanda baca atau simbol tanpa huruf/angka, kosongkan
+  if (/^[^a-zA-Z0-9]+$/.test(stripped)) {
+    return ''
+  }
+
+  return stripped
+}