amiru 0.0.0-stage → 0.2.0

package/src/store.js

@@ -0,0 +1,251 @@
+import { createHash, randomUUID } from 'node:crypto'
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync,
+} from 'node:fs'
+import { dirname, join } from 'node:path'
+
+function readJson(path, fallback) {
+  try {
+    if (!existsSync(path)) return fallback
+    const text = readFileSync(path, 'utf8').trim()
+    if (!text) return fallback
+    return JSON.parse(text)
+  } catch {
+    return fallback
+  }
+}
+
+function writeJsonAtomic(path, value) {
+  mkdirSync(dirname(path), { recursive: true })
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+  renameSync(tmp, path)
+}
+
+function textOfMessage(message) {
+  const content = message?.content
+  if (!Array.isArray(content)) return ''
+  return content
+    .filter((block) => block && block.type === 'text' && typeof block.text === 'string')
+    .map((block) => block.text)
+    .join('\n')
+    .trim()
+}
+
+function truncate(text, max) {
+  const s = String(text ?? '').replace(/\s+/g, ' ').trim()
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s
+}
+
+export function bindingIdFor(accountId, chatKey) {
+  return createHash('sha256').update(`${accountId}|${chatKey}`).digest('hex').slice(0, 24)
+}
+
+export class AmiruStore {
+  constructor(dataDir) {
+    this.dir = dataDir
+    this.bindingsPath = join(dataDir, 'bindings.json')
+    this.memoriesPath = join(dataDir, 'memories.json')
+    this.messagesPath = join(dataDir, 'messages.jsonl')
+    this.bindings = readJson(this.bindingsPath, {})
+    this.memories = readJson(this.memoriesPath, {})
+    this.messages = this.#loadMessages()
+    mkdirSync(dataDir, { recursive: true })
+  }
+
+  #loadMessages() {
+    if (!existsSync(this.messagesPath)) return []
+    try {
+      const lines = readFileSync(this.messagesPath, 'utf8').split('\n')
+      const out = []
+      for (const line of lines) {
+        if (!line.trim()) continue
+        try {
+          out.push(JSON.parse(line))
+        } catch {
+          // One torn line must not make the rest of the diary unreadable.
+        }
+      }
+      return out.slice(-5000)
+    } catch {
+      return []
+    }
+  }
+
+  #saveBindings() {
+    writeJsonAtomic(this.bindingsPath, this.bindings)
+  }
+
+  #saveMemories() {
+    writeJsonAtomic(this.memoriesPath, this.memories)
+  }
+
+  getBinding(bindingId) {
+    return this.bindings[bindingId]
+  }
+
+  getBindingBySession(sessionId) {
+    return Object.values(this.bindings).find((b) => b.sessionId === sessionId)
+  }
+
+  listBindings() {
+    return Object.values(this.bindings)
+  }
+
+  ensureBinding({ accountId, chatKey, scope, peerId, sessionId, appId, personaId }) {
+    const bindingId = bindingIdFor(accountId, chatKey)
+    let binding = this.bindings[bindingId]
+    const now = Date.now()
+    if (!binding) {
+      binding = {
+        bindingId,
+        accountId,
+        appId,
+        chatKey,
+        scope,
+        peerId,
+        sessionId,
+        personaId: personaId || 'default',
+        createdAt: now,
+        lastUserAt: 0,
+        lastAssistantAt: 0,
+        lastProactiveAt: 0,
+        proactiveDay: '',
+        proactiveCount: 0,
+        unansweredProactive: 0,
+        userMessageCount: 0,
+        assistantMessageCount: 0,
+        proactiveEnabled: true,
+        optedOut: false,
+      }
+    } else if (binding.sessionId !== sessionId) {
+      binding.sessionId = sessionId
+    }
+    this.bindings[bindingId] = binding
+    this.#saveBindings()
+    return binding
+  }
+
+  updateBinding(bindingId, patch) {
+    const binding = this.bindings[bindingId]
+    if (!binding) return undefined
+    Object.assign(binding, patch)
+    this.#saveBindings()
+    return binding
+  }
+
+  setPersona(bindingId, personaId) {
+    return this.updateBinding(bindingId, { personaId })
+  }
+
+  appendMessage({ bindingId, sessionId, role, message, time = Date.now() }) {
+    const text = textOfMessage(message)
+    if (!text) return null
+    const row = {
+      id: randomUUID(),
+      bindingId,
+      sessionId,
+      role,
+      text,
+      time,
+    }
+    appendFileSync(this.messagesPath, `${JSON.stringify(row)}\n`, 'utf8')
+    this.messages.push(row)
+    if (this.messages.length > 5000) this.messages.splice(0, this.messages.length - 5000)
+    return row
+  }
+
+  recentMessages(bindingId, limit = 10, { excludeSessionId } = {}) {
+    const rows = this.messages.filter(
+      (m) => m.bindingId === bindingId && (!excludeSessionId || m.sessionId !== excludeSessionId),
+    )
+    return rows.slice(-limit)
+  }
+
+  previousSessionMessages(bindingId, currentSessionId, limit = 10) {
+    const rows = this.messages.filter(
+      (m) => m.bindingId === bindingId && m.sessionId !== currentSessionId,
+    )
+    return rows.slice(-limit)
+  }
+
+  addMemory(bindingId, { text, kind = 'note', importance = 3 }) {
+    const value = String(text ?? '').trim()
+    if (!value) return null
+    const item = {
+      id: randomUUID(),
+      bindingId,
+      text: value.slice(0, 1000),
+      kind: String(kind || 'note').slice(0, 40),
+      importance: Math.max(1, Math.min(5, Number(importance) || 3)),
+      time: Date.now(),
+    }
+    const list = this.memories[bindingId] ?? []
+    list.push(item)
+    this.memories[bindingId] = list.slice(-200)
+    this.#saveMemories()
+    return item
+  }
+
+  listMemories(bindingId, limit = 8) {
+    const list = this.memories[bindingId] ?? []
+    return [...list]
+      .sort((a, b) => (b.importance - a.importance) || (b.time - a.time))
+      .slice(0, limit)
+  }
+
+  recordUserMessage(bindingId, time = Date.now()) {
+    const b = this.bindings[bindingId]
+    if (!b) return
+    b.lastUserAt = time
+    b.userMessageCount = (b.userMessageCount || 0) + 1
+    b.unansweredProactive = 0
+    this.#saveBindings()
+  }
+
+  recordAssistantMessage(bindingId, time = Date.now()) {
+    const b = this.bindings[bindingId]
+    if (!b) return
+    b.lastAssistantAt = time
+    b.assistantMessageCount = (b.assistantMessageCount || 0) + 1
+    this.#saveBindings()
+  }
+
+  recordProactive(bindingId, day, time = Date.now()) {
+    const b = this.bindings[bindingId]
+    if (!b) return
+    if (b.proactiveDay !== day) {
+      b.proactiveDay = day
+      b.proactiveCount = 0
+    }
+    b.lastProactiveAt = time
+    b.proactiveCount = (b.proactiveCount || 0) + 1
+    b.unansweredProactive = (b.unansweredProactive || 0) + 1
+    this.#saveBindings()
+  }
+
+  stats(bindingId) {
+    const b = this.bindings[bindingId]
+    if (!b) return null
+    const messages = this.messages.filter((m) => m.bindingId === bindingId)
+    return {
+      binding: b,
+      messages: messages.length,
+      memories: (this.memories[bindingId] ?? []).length,
+      lastMessage: messages.at(-1) ?? null,
+    }
+  }
+}
+
+export function extractMessageText(message) {
+  return textOfMessage(message)
+}
+
+export function shorten(text, max = 160) {
+  return truncate(text, max)
+}