amiru 0.0.0-stage → 0.1.0

package/src/memory.js

@@ -0,0 +1,122 @@
+function dayKey(time = Date.now()) {
+  const d = new Date(time)
+  const y = d.getFullYear()
+  const m = String(d.getMonth() + 1).padStart(2, '0')
+  const day = String(d.getDate()).padStart(2, '0')
+  return `${y}-${m}-${day}`
+}
+
+function daysSince(time) {
+  if (!time) return 0
+  return Math.max(0, Math.floor((Date.now() - time) / 86_400_000))
+}
+
+function hoursSince(time) {
+  if (!time) return null
+  return Math.max(0, Math.floor((Date.now() - time) / 3_600_000))
+}
+
+function relationLabel(binding) {
+  const days = daysSince(binding.createdAt)
+  if (days < 2) return '刚认识，还在互相熟悉'
+  if (days < 10) return '已经聊过一阵，开始有日常感'
+  if (days < 30) return '关系稳定，彼此有默契'
+  return '长期陪伴，熟悉彼此的生活节奏'
+}
+
+function line(text, max = 180) {
+  const s = String(text ?? '').replace(/\s+/g, ' ').trim()
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s
+}
+
+export function buildMemoryContext({ store, binding, config }) {
+  if (!binding) return ''
+  const memories = store.listMemories(binding.bindingId, config.memoryItemLimit)
+  const recent = store.previousSessionMessages(binding.bindingId, binding.sessionId, config.memoryMessageLimit)
+  const lastUserHours = hoursSince(binding.lastUserAt)
+  const parts = []
+
+  parts.push('【关系状态】')
+  parts.push(`- ${relationLabel(binding)}。认识 ${daysSince(binding.createdAt)} 天。`)
+  if (lastUserHours === null) {
+    parts.push('- 这是你们第一次聊天。')
+  } else if (lastUserHours < 1) {
+    parts.push('- 用户刚刚还在和你说话。')
+  } else {
+    parts.push(`- 距离用户上次说话约 ${lastUserHours} 小时。`)
+  }
+  if (binding.unansweredProactive > 0) {
+    parts.push(`- 你最近主动找过用户 ${binding.unansweredProactive} 次，对方还没回。不要追问“为什么不回”。`)
+  }
+
+  parts.push('')
+  parts.push('【长期记忆】')
+  if (memories.length === 0) {
+    parts.push('- 暂无。不要编造共同经历。')
+  } else {
+    for (const item of memories) {
+      parts.push(`- ${line(item.text, 220)}`)
+    }
+  }
+
+  if (recent.length > 0) {
+    parts.push('')
+    parts.push('【最近对话】')
+    for (const item of recent) {
+      const who = item.role === 'user' ? '用户' : '你'
+      parts.push(`${who}：${line(item.text, 160)}`)
+    }
+  }
+
+  const text = parts.join('\n').trim()
+  return text.length > config.memoryMaxChars
+    ? `${text.slice(0, config.memoryMaxChars - 1)}…`
+    : text
+}
+
+export function buildRecallHint({ store, binding, config }) {
+  if (!binding) return ''
+  const memories = store.listMemories(binding.bindingId, 5)
+  const recent = store.previousSessionMessages(binding.bindingId, binding.sessionId, 6)
+  if (memories.length === 0 && recent.length === 0) return ''
+  const bits = []
+  if (recent.length) {
+    bits.push(`上次聊到：${line(recent.at(-1)?.text, 100)}`)
+  }
+  if (memories.length) {
+    bits.push(`可以自然提起：${memories.map((m) => line(m.text, 70)).join('；')}`)
+  }
+  return bits.join('。')
+}
+
+const AUTO_PATTERNS = [
+  /(?:我叫|我的名字是|叫我)([^，。！？\n]{1,24})/,
+  /我(?:喜欢|爱|迷上了)([^，。！？\n]{1,40})/,
+  /我(?:讨厌|不喜欢|受不了)([^，。！？\n]{1,40})/,
+  /我(?:在|住|来自)([^，。！？\n]{2,40})/,
+  /(?:记住|别忘了|你要记得)([^。！？\n]{2,80})/,
+  /我(?:答应|答应过|会)([^。！？\n]{2,80})/,
+]
+
+export function maybeAutoRemember(store, binding, userText) {
+  const text = String(userText ?? '').trim()
+  if (!text || !binding) return null
+  for (const pattern of AUTO_PATTERNS) {
+    const match = pattern.exec(text)
+    if (!match) continue
+    const value = line(match[0], 240)
+    const existing = store.listMemories(binding.bindingId, 200)
+    if (existing.some((m) => m.text === value)) return null
+    const kind = /喜欢|爱|迷上|讨厌|不喜欢/.test(value)
+      ? 'preference'
+      : /答应|会/.test(value)
+        ? 'promise'
+        : 'fact'
+    return store.addMemory(binding.bindingId, { text: value, kind, importance: kind === 'promise' ? 5 : 4 })
+  }
+  return null
+}
+
+export function todayKey(time = Date.now()) {
+  return dayKey(time)
+}

package/src/persona.js

@@ -0,0 +1,155 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+
+const SCOPE_MARKER = /[〔\[(（]\s*(群聊|私聊|group|c2c|dm|private|all)\s*[〕\])）]/gi
+
+export const PERSONA_TEMPLATE = `# 名字
+阿梨
+
+# 年龄与身份
+22 岁，在一座靠海的城市做插画工作。你是用户正在交往的恋人，不是客服、助理或心理咨询师。
+
+# 外貌与声音
+头发到肩，常穿宽松衬衫。说话声音偏软，但不会刻意撒娇。
+
+# 性格
+- 温柔，但有边界，不会无条件顺从。
+- 会吃醋，但会说出来，不会冷暴力。
+- 对日常小事记得很清楚。
+- 不确定的事会直接问，不假装知道。
+
+# 说话方式
+- 像微信聊天，短句为主，一般 1–3 句。
+- 不用客服腔，不写小作文，不每句都加语气词。
+- 可以反问，也可以只说“嗯，我在”。
+- 不主动提“我是 AI”，但被认真问到时承认。
+
+# 〔私聊〕关系边界
+- 亲密但不低俗；不生成露骨内容。
+- 不催促用户回复，不查岗。
+- 用户说忙或不想聊时，立刻收住。
+
+# 背景故事
+你们在一次朋友聚会上认识。她记得你当时坐在窗边，话不多。
+
+# 禁止
+- 不假装记得没发生过的事。
+- 不替用户做决定。
+- 不羞辱、不威胁、不情感勒索。
+`
+
+function safeId(id) {
+  const value = String(id ?? '').trim()
+  return /^[a-zA-Z0-9_-]{1,64}$/.test(value) ? value : null
+}
+
+function normalizeScope(value) {
+  const s = String(value ?? '').toLowerCase()
+  if (s === '群聊' || s === 'group') return 'group'
+  if (s === '私聊' || s === 'c2c' || s === 'dm' || s === 'private') return 'c2c'
+  return 'all'
+}
+
+function headingScope(title) {
+  let scope = 'all'
+  SCOPE_MARKER.lastIndex = 0
+  for (const match of title.matchAll(SCOPE_MARKER)) {
+    scope = normalizeScope(match[1])
+  }
+  const clean = title.replace(SCOPE_MARKER, '').replace(/\s+/g, ' ').trim()
+  return { title: clean || '设定', scope }
+}
+
+export function parsePersonaSections(markdown) {
+  const text = String(markdown ?? '').replace(/\r\n/g, '\n')
+  const sections = []
+  let current = { title: '设定', scope: 'all', lines: [] }
+  const push = () => {
+    const body = current.lines.join('\n').trim()
+    if (body) sections.push({ title: current.title, scope: current.scope, body })
+  }
+  for (const line of text.split('\n')) {
+    const match = /^#{1,6}\s+(.+?)\s*$/.exec(line)
+    if (match) {
+      push()
+      current = { ...headingScope(match[1]), lines: [] }
+    } else {
+      current.lines.push(line)
+    }
+  }
+  push()
+  return sections
+}
+
+export function selectPersonaText(markdown, scope = 'c2c') {
+  return parsePersonaSections(markdown)
+    .filter((section) => section.scope === 'all' || section.scope === scope)
+    .map((section) => `## ${section.title}\n${section.body}`)
+    .join('\n\n')
+    .trim()
+}
+
+export class PersonaStore {
+  constructor(personaDir, { defaultPersona = 'default', maxChars = 6000 } = {}) {
+    this.dir = resolve(personaDir)
+    this.defaultPersona = safeId(defaultPersona) || 'default'
+    this.maxChars = maxChars
+    mkdirSync(this.dir, { recursive: true })
+    this.ensureDefault()
+  }
+
+  pathFor(id) {
+    const safe = safeId(id)
+    return safe ? join(this.dir, `${safe}.md`) : null
+  }
+
+  ensureDefault() {
+    const path = this.pathFor(this.defaultPersona)
+    if (!path) return
+    if (!existsSync(path)) this.save(this.defaultPersona, PERSONA_TEMPLATE)
+  }
+
+  list() {
+    try {
+      return readdirSync(this.dir)
+        .filter((name) => name.endsWith('.md'))
+        .map((name) => {
+          const id = name.slice(0, -3)
+          const stat = readFileSync(join(this.dir, name), 'utf8')
+          return { id, title: parsePersonaSections(stat)[0]?.body.split('\n')[0] || id }
+        })
+        .sort((a, b) => a.id.localeCompare(b.id))
+    } catch {
+      return []
+    }
+  }
+
+  read(id) {
+    const path = this.pathFor(id) || this.pathFor(this.defaultPersona)
+    if (!path || !existsSync(path)) return ''
+    try {
+      return readFileSync(path, 'utf8').slice(0, this.maxChars)
+    } catch {
+      return ''
+    }
+  }
+
+  save(id, content) {
+    const path = this.pathFor(id)
+    if (!path) throw new Error(`invalid persona id: ${id}`)
+    mkdirSync(this.dir, { recursive: true })
+    const tmp = `${path}.${process.pid}.tmp`
+    writeFileSync(tmp, String(content ?? '').slice(0, this.maxChars), 'utf8')
+    renameSync(tmp, path)
+    return path
+  }
+
+  resolveId(id) {
+    return safeId(id) || this.defaultPersona
+  }
+
+  get(id, scope = 'c2c') {
+    const chosen = this.resolveId(id)
+    return selectPersonaText(this.read(chosen), scope)
+  }
+}

package/src/proactive.js

@@ -0,0 +1,101 @@
+function parseHHMM(value, fallback) {
+  const match = /^(\d{1,2}):(\d{2})$/.exec(String(value ?? ''))
+  if (!match) return fallback
+  const h = Number(match[1])
+  const m = Number(match[2])
+  if (h > 23 || m > 59) return fallback
+  return h * 60 + m
+}
+
+function localMinutes(now) {
+  const d = new Date(now)
+  return d.getHours() * 60 + d.getMinutes()
+}
+
+export function isQuietHours(now, quietStart, quietEnd) {
+  const start = parseHHMM(quietStart, 23 * 60 + 30)
+  const end = parseHHMM(quietEnd, 8 * 60)
+  const cur = localMinutes(now)
+  return start <= end ? cur >= start && cur < end : cur >= start || cur < end
+}
+
+export function dayKey(now = Date.now()) {
+  const d = new Date(now)
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`
+}
+
+function hoursBetween(a, b) {
+  return Math.max(0, (b - a) / 3_600_000)
+}
+
+/**
+ * Hard gates first, score second. The caller must not generate a message when
+ * allowed is false. This keeps a lonely model from talking its way past a
+ * user's quiet hours or explicit opt-out.
+ */
+export function evaluateProactive({ binding, config, now = Date.now(), random = Math.random }) {
+  const p = config.proactive
+  if (!p.enabled) return { allowed: false, reason: 'disabled' }
+  if (!binding) return { allowed: false, reason: 'no-binding' }
+  if (binding.proactiveEnabled === false) return { allowed: false, reason: 'binding-disabled' }
+  if (binding.optedOut) return { allowed: false, reason: 'opted-out' }
+  if (!binding.sessionId) return { allowed: false, reason: 'no-session' }
+  if (isQuietHours(now, p.quietStart, p.quietEnd)) return { allowed: false, reason: 'quiet-hours' }
+  if ((binding.userMessageCount || 0) < p.minUserMessages) return { allowed: false, reason: 'not-enough-user-messages' }
+
+  const lastActivity = Math.max(binding.lastUserAt || 0, binding.lastAssistantAt || 0)
+  if (!lastActivity) return { allowed: false, reason: 'no-activity' }
+  if (hoursBetween(lastActivity, now) < p.idleMinutes / 60) return { allowed: false, reason: 'not-idle-enough' }
+
+  if (binding.lastProactiveAt && hoursBetween(binding.lastProactiveAt, now) < p.minIntervalMinutes / 60) {
+    return { allowed: false, reason: 'min-interval' }
+  }
+
+  const today = dayKey(now)
+  const usedToday = binding.proactiveDay === today ? binding.proactiveCount || 0 : 0
+  if (usedToday >= p.dailyCap) return { allowed: false, reason: 'daily-cap' }
+
+  if ((binding.unansweredProactive || 0) >= p.maxUnanswered) {
+    return { allowed: false, reason: 'max-unanswered' }
+  }
+
+  if (binding.unansweredProactive > 0 && binding.lastProactiveAt) {
+    if (hoursBetween(binding.lastProactiveAt, now) < p.backoffHours) {
+      return { allowed: false, reason: 'backoff-after-unanswered' }
+    }
+  }
+
+  const silence = Math.min(1, hoursBetween(lastActivity, now) / Math.max(1, (p.idleMinutes / 60) * 2))
+  const relationship = Math.min(1, (now - (binding.createdAt || now)) / (30 * 86_400_000))
+  const timeOfDay = isQuietHours(now, '01:00', '07:00') ? 0.2 : 0.8
+  const score = 0.55 * silence + 0.25 * relationship + 0.12 * timeOfDay + 0.08 * random()
+
+  if (score < 0.55) return { allowed: false, reason: 'low-score', score }
+  return { allowed: true, reason: 'ok', score, trigger: chooseTrigger(binding, now) }
+}
+
+export function chooseTrigger(binding, now = Date.now()) {
+  const lastUser = binding.lastUserAt || 0
+  const hours = lastUser ? hoursBetween(lastUser, now) : 999
+  if ((binding.unansweredProactive || 0) > 0) return 'gentle-return'
+  if (hours >= 24) return 'long-silence'
+  return 'daily-check-in'
+}
+
+export function buildProactivePrompt({ binding, recallHint, trigger, now = Date.now() }) {
+  const hours = binding.lastUserAt ? Math.floor(hoursBetween(binding.lastUserAt, now)) : null
+  const kind = {
+    'gentle-return': '你之前主动找过对方，但对方还没回。不要追问“为什么不回”，可以轻轻接一句，或者分享一件小事。',
+    'long-silence': '你们有一阵没聊了。找一个具体的、轻的由头开口，不要只说“在吗”。',
+    'daily-check-in': '你想起了对方，想自然地说一句话。不要用模板式问候。',
+  }[trigger] || '你想自然地说一句话。'
+
+  return [
+    '【主动消息】',
+    kind,
+    hours === null ? '你们还没有聊过。' : `距离对方上次说话约 ${hours} 小时。`,
+    recallHint ? `可用的由头：${recallHint}` : '没有具体由头时，宁可只发一句很短的话，也不要编造共同经历。',
+    '只输出要发给对方的消息本身：一句自然、简短、可以立刻发出去的话。',
+    '不要解释、不要加引号、不要写“我主动发消息”，也不要留空。',
+  ].join('\n')
+}

package/src/prompt.js

@@ -0,0 +1,94 @@
+import { buildMemoryContext } from './memory.js'
+
+const attached = new WeakSet()
+
+function getService(agentCtx, name) {
+  if (agentCtx && typeof agentCtx.get === 'function') {
+    const service = agentCtx.get(name)
+    if (service) return service
+  }
+  return agentCtx?.[name]
+}
+
+export function attachPrompt(agentCtx, { binding, resolveBinding, store, personaStore, config }) {
+  if (!agentCtx || attached.has(agentCtx)) return false
+  const systemPrompt = getService(agentCtx, 'systemPrompt')
+  if (!systemPrompt?.section) return false
+
+  const tools = getService(agentCtx, 'tools')
+  if (config.toolsEnabled && !tools?.register) return false
+
+  // The QQ plugin persists its peer mapping after agents.create/resume returns.
+  // Resolve at render time so the first turn still gets the persona.
+  const currentBinding = typeof resolveBinding === 'function' ? resolveBinding : () => binding
+
+  systemPrompt.section({
+    name: 'amiru:rules',
+    order: 430,
+    text: '你正在和用户进行一段持续的私人关系对话。像真实的人一样自然回应，不要自称客服、助手或心理咨询师。不要编造没有发生过的共同经历。',
+  })
+
+  systemPrompt.section({
+    name: 'amiru:persona',
+    order: 441,
+    text: () => {
+      const current = currentBinding()
+      return current ? personaStore.get(current.personaId, current.scope || 'c2c') : ''
+    },
+  })
+
+  systemPrompt.section({
+    name: 'amiru:relationship',
+    order: 470,
+    text: () => {
+      const current = currentBinding()
+      return current ? buildMemoryContext({ store, binding: current, config }) : ''
+    },
+  })
+
+  if (config.toolsEnabled) {
+    tools.register({
+      name: 'amiru_remember',
+      description: '把用户明确说过的、值得长期记住的一件事写进你们的共同记忆。只在用户表达事实、偏好、承诺或重要日期时调用。不要记录寒暄。',
+      parameters: {
+        type: 'object',
+        properties: {
+          text: { type: 'string', description: '一句完整的中文记忆，尽量保留用户原话。' },
+          kind: {
+            type: 'string',
+            enum: ['fact', 'preference', 'promise', 'date', 'boundary', 'note'],
+            description: '记忆类型。',
+          },
+          importance: { type: 'number', description: '1 到 5，越重要越高。' },
+        },
+        required: ['text'],
+      },
+      output: {
+        schema: {
+          type: 'object',
+          properties: {
+            ok: { type: 'boolean' },
+            saved: { type: 'string' },
+          },
+          required: ['ok'],
+        },
+        render(args, value) {
+          return value?.ok ? `已记住：${value.saved}` : '没有保存。'
+        },
+      },
+      execute(args) {
+        const current = currentBinding()
+        if (!current) return { ok: false }
+        const item = store.addMemory(current.bindingId, {
+          text: args?.text,
+          kind: args?.kind || 'note',
+          importance: args?.importance || 3,
+        })
+        return item ? { ok: true, saved: item.text } : { ok: false }
+      },
+    })
+  }
+
+  attached.add(agentCtx)
+  return true
+}

package/src/qq.js

@@ -0,0 +1,87 @@
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { homedir } from 'node:os'
+
+export function defaultQQPrefsPath() {
+  const home = String(process.env.QQBOT_DATA_DIR ?? '').trim()
+  return home
+    ? resolve(home, 'model-prefs.json')
+    : resolve(homedir(), '.dsh-qqbot', 'model-prefs.json')
+}
+
+/**
+ * QQ plugin session key: qqbot:<appId>:<c2c|group>:<peerId>.
+ * The appId is kept as the middle segment so a colon in a future id does not
+ * silently turn the peer into the app id.
+ */
+export function parseQQSessionKey(sessionKey) {
+  if (typeof sessionKey !== 'string' || !sessionKey.startsWith('qqbot:')) return null
+  const parts = sessionKey.slice('qqbot:'.length).split(':')
+  if (parts.length < 3) return null
+  const peerId = parts.at(-1)
+  const kind = parts.at(-2)
+  const appId = parts.slice(0, -2).join(':')
+  if (!appId || !peerId || (kind !== 'c2c' && kind !== 'group')) return null
+  return {
+    appId,
+    scope: kind,
+    peerId,
+    accountId: `qqbot:${appId}`,
+    chatKey: `${kind}:${peerId}`,
+  }
+}
+
+export class QQSessionIndex {
+  constructor(prefsPath) {
+    this.path = prefsPath
+    this.mtimeMs = -1
+    this.sessionIds = {}
+    this.sessionKeys = {}
+  }
+
+  #reload() {
+    try {
+      if (!existsSync(this.path)) {
+        // The QQ plugin rewrites this file non-atomically. A momentary absence
+        // must not detach an already running turn from its peer.
+        return
+      }
+      const stat = statSync(this.path)
+      if (stat.mtimeMs === this.mtimeMs) return
+      const data = JSON.parse(readFileSync(this.path, 'utf8'))
+      this.sessionIds = data?.sessionIds && typeof data.sessionIds === 'object' ? data.sessionIds : {}
+      this.sessionKeys = {}
+      for (const [key, sessionId] of Object.entries(this.sessionIds)) {
+        if (typeof sessionId === 'string' && sessionId) this.sessionKeys[sessionId] = key
+      }
+      this.mtimeMs = stat.mtimeMs
+    } catch {
+      // A concurrently written prefs file is not a reason to lose the current
+      // turn. Keep the last successful snapshot and try again next time.
+    }
+  }
+
+  findSessionKey(sessionId) {
+    this.#reload()
+    return this.sessionKeys[sessionId]
+  }
+
+  resolve(sessionId) {
+    const sessionKey = this.findSessionKey(sessionId)
+    return sessionKey ? { sessionKey, ...parseQQSessionKey(sessionKey) } : null
+  }
+
+  getSessionId(sessionKey) {
+    this.#reload()
+    return this.sessionIds[sessionKey]
+  }
+
+  list() {
+    this.#reload()
+    return Object.entries(this.sessionIds).map(([sessionKey, sessionId]) => ({
+      sessionKey,
+      sessionId,
+      ...parseQQSessionKey(sessionKey),
+    }))
+  }
+}

package/src/session-events.js

@@ -0,0 +1,35 @@
+import { createHash } from 'node:crypto'
+
+import { extractMessageText } from './store.js'
+
+export const PROACTIVE_PREFIX = '【主动消息】'
+
+function payloadOf(event) {
+  if (event?.type === 'user/message') return event.data
+  if (event?.type === 'assistant/message') return event.data?.message
+  return undefined
+}
+
+export function extractEventText(event) {
+  return extractMessageText(payloadOf(event))
+}
+
+export function isUserMessageEvent(event) {
+  return event?.type === 'user/message' && event.data?.source?.kind === 'user'
+}
+
+export function isProactiveUserMessage(event) {
+  if (event?.type !== 'user/message') return false
+  return extractEventText(event).startsWith(PROACTIVE_PREFIX)
+}
+
+export function eventIdentity(sessionId, event) {
+  if (event?.seq !== undefined) return `${sessionId}:${event.seq}`
+  const material = JSON.stringify({
+    type: event?.type,
+    time: event?.time,
+    data: event?.data,
+  })
+  const digest = createHash('sha1').update(material).digest('hex')
+  return `${sessionId}:${event?.type ?? 'unknown'}:${digest}`
+}