@mazees/mark 5.0.0

package/src/server/ws-hub.js

@@ -0,0 +1,168 @@
+import { WebSocketServer, WebSocket } from 'ws'
+
+/**
+ * WebSocket Hub untuk MARK Core.
+ * Mengelola koneksi real-time antara Node.js Core Backend, WebUI Client, dan CLI Streamer.
+ */
+class WebSocketHub {
+  constructor() {
+    this.wss = null
+    this.clients = new Set()
+    this.eventHandlers = new Map()
+  }
+
+  /**
+   * Inisialisasi WebSocket Server pada HTTP Server yang ada
+   * @param {import('http').Server} server
+   */
+  init(server) {
+    this.wss = new WebSocketServer({ server, path: '/stream' })
+    this.uiClients = new Set()
+
+    this.wss.on('error', (err) => {
+      // Delegasikan error EADDRINUSE ke HTTP Server listener agar auto-fallback berjalan
+      if (err.code !== 'EADDRINUSE') {
+        console.error('[WebSocket Hub Error]:', err)
+      }
+    })
+
+    this.wss.on('connection', (ws) => {
+      this.clients.add(ws)
+
+      // Kirim event sambutan ready dan status presence UI terkini
+      this.send(ws, 'core:ready', {
+        version: '5.0.0',
+        timestamp: Date.now()
+      })
+      this.send(ws, 'ui:status', {
+        active: this.uiClients.size > 0,
+        count: this.uiClients.size
+      })
+
+      ws.on('message', (data) => {
+        try {
+          const parsed = JSON.parse(data.toString())
+          const { event, id, payload } = parsed
+
+          if (event === 'ui:presence') {
+            this.uiClients.add(ws)
+            this.broadcast('ui:status', {
+              active: true,
+              count: this.uiClients.size
+            })
+          } else if (event === 'ui:goodbye') {
+            this.uiClients.delete(ws)
+            this.broadcast('ui:status', {
+              active: this.uiClients.size > 0,
+              count: this.uiClients.size
+            })
+          } else if (event) {
+            this.handleIncomingEvent(ws, event, payload, id)
+          }
+        } catch (_) {}
+      })
+
+      const cleanupClient = () => {
+        this.clients.delete(ws)
+        if (this.uiClients.has(ws)) {
+          this.uiClients.delete(ws)
+          this.broadcast('ui:status', {
+            active: this.uiClients.size > 0,
+            count: this.uiClients.size
+          })
+        }
+      }
+
+      ws.on('close', cleanupClient)
+      ws.on('error', cleanupClient)
+    })
+  }
+
+  /**
+   * Daftarkan handler event masuk dari client
+   * @param {string} event
+   * @param {Function} handler
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, [])
+    }
+    this.eventHandlers.get(event).push(handler)
+  }
+
+  /**
+   * Handle event yang dikirim dari WebUI / CLI
+   */
+  async handleIncomingEvent(ws, event, payload, id) {
+    const handlers = this.eventHandlers.get(event)
+    if (handlers && handlers.length > 0) {
+      for (const handler of handlers) {
+        try {
+          const result = await handler(payload, ws)
+          if (id) {
+            this.send(ws, `${event}:response`, { id, success: true, data: result })
+          }
+        } catch (err) {
+          if (id) {
+            this.send(ws, `${event}:response`, { id, success: false, error: err.message })
+          }
+        }
+      }
+    } else {
+      if (id) {
+        this.send(ws, `${event}:response`, {
+          id,
+          success: false,
+          error: `No handler for event ${event}`
+        })
+      }
+    }
+  }
+
+  /**
+   * Kirim pesan ke client tertentu
+   * @param {WebSocket} ws
+   * @param {string} event
+   * @param {any} payload
+   */
+  send(ws, event, payload) {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({ event, payload }))
+    }
+  }
+
+  /**
+   * Broadcast event ke SEMUA client yang terhubung (WebUI, CLI, dll)
+   * @param {string} event
+   * @param {any} payload
+   */
+  broadcast(event, payload) {
+    const message = JSON.stringify({ event, payload })
+    for (const client of this.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(message)
+      }
+    }
+  }
+
+  /**
+   * Streaming token AI langsung ke semua client
+   * @param {string} token
+   * @param {string} [type='answer'] 'thought' | 'answer'
+   */
+  streamToken(token, type = 'answer') {
+    this.broadcast('ai:token', { token, type, timestamp: Date.now() })
+  }
+
+  /**
+   * Emit status tool execution
+   * @param {string} toolName
+   * @param {string} status 'start' | 'running' | 'done' | 'error'
+   * @param {any} [data=null]
+   */
+  emitToolStatus(toolName, status, data = null) {
+    this.broadcast('tool:status', { tool: toolName, status, data, timestamp: Date.now() })
+  }
+}
+
+export const wsHub = new WebSocketHub()

package/src/shared/parsers/mark-tag-parser.js

@@ -0,0 +1,275 @@
+/**
+ * Unified Mark Tag Parser (V5)
+ * Modul isomorphic murni (kompatibel dengan Node.js backend dan browser frontend).
+ * Mendukung fixed schema (<mark mood="..." done="..." />), CoT reasoning (<think>),
+ * serta sanitasi tag legacy (<mood:...>, [mood:...]) dari teks output.
+ */
+
+export const VALID_MOODS = [
+  'neutral',
+  'joy',
+  'happy',
+  'sadness',
+  'sad',
+  'fear',
+  'anger',
+  'angry',
+  'disgust',
+  'anxiety',
+  'envy',
+  'embarrassment',
+  'ennui',
+  'thinking',
+  'sarcasm',
+  'focused',
+  'excited',
+  'confused',
+  'annoyed',
+  'calm'
+]
+
+export const MOOD_NORMALIZATION = {
+  happy: 'joy',
+  sad: 'sadness',
+  angry: 'anger',
+  bored: 'ennui',
+  anxious: 'anxiety'
+}
+
+export const MARK_TAG_SCHEMA = {
+  mood: {
+    type: 'string',
+    default: 'neutral',
+    validate: (val) => {
+      if (!val) return 'neutral'
+      const clean = String(val).trim().toLowerCase()
+      const normalized = MOOD_NORMALIZATION[clean] || clean
+      return VALID_MOODS.includes(normalized) ? normalized : 'neutral'
+    }
+  },
+  done: {
+    type: 'boolean',
+    default: false,
+    validate: (val) => {
+      if (val === true || val === 'true' || val === 1 || val === '1') return true
+      return false
+    }
+  }
+}
+
+const MARK_TAG_REGEX = /<mark\b([^>]*)\/?>/i
+const THINK_BLOCK_REGEX = /<think>([\s\S]*?)<\/think>/i
+const LEGACY_MOOD_REGEX = /(?:<|\[)mood:[a-zA-Z0-9_-]+(?:>|\])/gi
+const LEGACY_DONE_REGEX = /<\/?done\s*\/?>/gi
+
+/**
+ * Parsing atribut XML dari tag string ke objek JavaScript sesuai fixed schema.
+ * @param {string} attrString - String atribut di dalam tag <mark ...>
+ * @returns {Record<string, any>} Objek metadata yang divalidasi
+ */
+export function parseAttributes(attrString) {
+  const result = {
+    mood: MARK_TAG_SCHEMA.mood.default,
+    done: MARK_TAG_SCHEMA.done.default,
+    hasExplicitDone: false
+  }
+
+  if (!attrString || typeof attrString !== 'string') {
+    return result
+  }
+
+  const attrPattern = /([a-zA-Z0-9_-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/g
+  let match
+
+  while ((match = attrPattern.exec(attrString)) !== null) {
+    const rawKey = match[1].toLowerCase()
+    const rawValue = match[2] ?? match[3] ?? match[4] ?? ''
+
+    if (rawKey in MARK_TAG_SCHEMA) {
+      result[rawKey] = MARK_TAG_SCHEMA[rawKey].validate(rawValue)
+      if (rawKey === 'done') {
+        result.hasExplicitDone = true
+      }
+    }
+  }
+
+  return result
+}
+
+/**
+ * Membersihkan semua tag kontrol (V5 dan legacy) dari teks agar riwayat dan tampilan bersih.
+ * @param {string} text - Teks mentah dari AI
+ * @returns {string} Teks bersih bebas dari tag kontrol
+ */
+export function stripMarkTags(text) {
+  if (!text || typeof text !== 'string') return ''
+
+  return text
+    .replace(THINK_BLOCK_REGEX, '')
+    .replace(MARK_TAG_REGEX, '')
+    .replace(/<\/mark>/gi, '')
+    .replace(LEGACY_MOOD_REGEX, '')
+    .replace(LEGACY_DONE_REGEX, '')
+    .replace(/^\s+/, '')
+}
+
+/**
+ * Parsing teks respons AI untuk mengekstrak metadata <mark>, CoT reasoning, dan cleanContent.
+ * @param {string} rawText - Teks mentah dari AI
+ * @returns {{ meta: { mood: string, done: boolean, hasTag: boolean, hasExplicitDone: boolean }, reasoning: string, cleanContent: string }}
+ */
+export function parseMarkTag(rawText) {
+  if (!rawText || typeof rawText !== 'string') {
+    return {
+      meta: {
+        mood: MARK_TAG_SCHEMA.mood.default,
+        done: MARK_TAG_SCHEMA.done.default,
+        hasTag: false,
+        hasExplicitDone: false
+      },
+      reasoning: '',
+      cleanContent: ''
+    }
+  }
+
+  // 1. Ekstraksi CoT Reasoning (<think>...</think>)
+  let reasoning = ''
+  const thinkMatch = rawText.match(THINK_BLOCK_REGEX)
+  if (thinkMatch) {
+    reasoning = thinkMatch[1].trim()
+  }
+
+  // 2. Ekstraksi Tag <mark ... />
+  let meta = {
+    mood: MARK_TAG_SCHEMA.mood.default,
+    done: MARK_TAG_SCHEMA.done.default,
+    hasTag: false,
+    hasExplicitDone: false
+  }
+
+  const markMatch = rawText.match(MARK_TAG_REGEX)
+  if (markMatch) {
+    const attrString = markMatch[1]
+    const parsedAttrs = parseAttributes(attrString)
+    meta = {
+      ...parsedAttrs,
+      hasTag: true
+    }
+  }
+
+  // 3. Sanitasi teks untuk tampilan dan penyimpanan
+  const cleanContent = stripMarkTags(rawText)
+
+  return {
+    meta,
+    reasoning,
+    cleanContent
+  }
+}
+
+/**
+ * Factory untuk membuat stream filter stateful.
+ * Mem-buffer awal stream untuk mendeteksi <mark ... />, memicu onMeta, dan menyalurkan chunk bersih.
+ * @param {{ onMeta?: (meta: { mood: string, done: boolean }) => void, onChunk?: (chunk: string) => void }} callbacks
+ */
+export function createMarkStreamFilter({ onMeta, onChunk } = {}) {
+  let flushed = false
+  let buffer = ''
+  const MAX_BUFFER_LENGTH = 160
+
+  const emitMeta = (meta) => {
+    if (typeof onMeta === 'function') {
+      try {
+        onMeta(meta)
+      } catch (err) {
+        console.error('[MarkStreamFilter] Error in onMeta callback:', err)
+      }
+    }
+  }
+
+  const emitChunk = (chunk) => {
+    if (chunk && typeof onChunk === 'function') {
+      onChunk(chunk)
+    }
+  }
+
+  return {
+    /**
+     * Memproses potongan token baru dari stream.
+     * @param {string} chunk - Potongan teks token
+     */
+    write(chunk) {
+      if (typeof chunk !== 'string') return
+
+      if (flushed) {
+        emitChunk(chunk)
+        return
+      }
+
+      buffer += chunk
+
+      // Cari apakah tag <mark ... /> sudah lengkap di dalam buffer
+      const markMatch = buffer.match(MARK_TAG_REGEX)
+      if (markMatch) {
+        const meta = parseAttributes(markMatch[1])
+        emitMeta(meta)
+
+        // Hapus tag <mark ... /> dari buffer dan trim newline awal jika ada
+        const tagIndex = buffer.indexOf(markMatch[0])
+        const afterTag = buffer.slice(tagIndex + markMatch[0].length).replace(/^[\r\n]+/, '')
+        flushed = true
+        buffer = ''
+
+        if (afterTag.length > 0) {
+          emitChunk(afterTag)
+        }
+        return
+      }
+
+      // Jika buffer melebihi batas atau ada baris baru tanpa awalan tag, flush default
+      const trimmed = buffer.trimStart()
+      const hasNewlineWithoutTag = trimmed.includes('\n') && !trimmed.startsWith('<')
+      if (buffer.length >= MAX_BUFFER_LENGTH || hasNewlineWithoutTag) {
+        emitMeta({
+          mood: MARK_TAG_SCHEMA.mood.default,
+          done: MARK_TAG_SCHEMA.done.default
+        })
+        flushed = true
+        const out = buffer
+        buffer = ''
+        emitChunk(out)
+      }
+    },
+
+    /**
+     * Menuntaskan stream jika stream berakhir sebelum buffer mencapai batas.
+     */
+    flush() {
+      if (flushed) return
+
+      const markMatch = buffer.match(MARK_TAG_REGEX)
+      if (markMatch) {
+        const meta = parseAttributes(markMatch[1])
+        emitMeta(meta)
+        const tagIndex = buffer.indexOf(markMatch[0])
+        const afterTag = buffer.slice(tagIndex + markMatch[0].length).replace(/^[\r\n]+/, '')
+        flushed = true
+        buffer = ''
+        if (afterTag.length > 0) {
+          emitChunk(afterTag)
+        }
+      } else {
+        emitMeta({
+          mood: MARK_TAG_SCHEMA.mood.default,
+          done: MARK_TAG_SCHEMA.done.default
+        })
+        flushed = true
+        const out = buffer
+        buffer = ''
+        if (out.length > 0) {
+          emitChunk(out)
+        }
+      }
+    }
+  }
+}