dsh-agent-soul 0.4.2 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/secrets.js ADDED
@@ -0,0 +1,173 @@
1
+ /**
2
+ * secrets.js —— 插件自己的凭据存储(2026-11-01)
3
+ *
4
+ * 为什么要有这一层:朋友给的 API key 不能写在 persona.json 里。
5
+ * 那个文件是明文、会被同步、会被整份贴进 issue;而 DSH 自己的
6
+ * `.credentials.yaml` 的 refs 段也是明文(`DEEPSEEK_API_KEY: sk-...`)——
7
+ * 插件不能假设宿主帮它兜底。
8
+ *
9
+ * 存储策略:
10
+ * · Windows → **DPAPI**(CurrentUser 范围)。密文绑当前用户账户,
11
+ * 拷到别的机器/别的账户都解不开。这是这台机器上能拿到的最硬的保护。
12
+ * · 其他平台 → 退化成 base64 + 0600 权限,并在日志里**明确说这不是加密**。
13
+ * 宁可说清楚,也不要让人以为拿了同等的保护。
14
+ *
15
+ * 注意:DPAPI 靠拉起一次 PowerShell 完成。只在读密钥时发生,且结果进内存缓存,
16
+ * 所以每个 DSH 进程最多付一次 ~300ms。
17
+ */
18
+ import { execFileSync } from 'node:child_process'
19
+ import { chmodSync, existsSync, mkdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'node:fs'
20
+ import { join } from 'node:path'
21
+ import { agentsDir } from './paths.js'
22
+ import { note } from './env.js'
23
+
24
+ const CACHE = new Map()
25
+ const NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,40}$/
26
+ const DPAPI_PREFIX = 'dpapi:'
27
+ const PLAIN_PREFIX = 'plain:'
28
+
29
+ export const secretsDir = () => join(agentsDir(), 'secrets')
30
+ export const secretPath = (name) => join(secretsDir(), `${String(name).trim()}.bin`)
31
+
32
+ function safeName(name) {
33
+ const value = String(name ?? '').trim()
34
+ return NAME_RE.test(value) ? value : ''
35
+ }
36
+
37
+ /** 跑一段 PowerShell,stdin 传数据(不把密钥放命令行参数里,进程列表里看不见)。 */
38
+ function powershell(script, input) {
39
+ return execFileSync('powershell', ['-NoProfile', '-NonInteractive', '-Command', script], {
40
+ input,
41
+ encoding: 'utf8',
42
+ timeout: 20000,
43
+ windowsHide: true
44
+ }).trim()
45
+ }
46
+
47
+ function dpapiAvailable() {
48
+ return process.platform === 'win32'
49
+ }
50
+
51
+ function encrypt(text) {
52
+ if (!dpapiAvailable()) {
53
+ return PLAIN_PREFIX + Buffer.from(text, 'utf8').toString('base64')
54
+ }
55
+ const out = powershell(
56
+ 'Add-Type -AssemblyName System.Security;'
57
+ + '$raw=[Console]::In.ReadToEnd().Trim();'
58
+ + '$b=[Convert]::FromBase64String($raw);'
59
+ + "$p=[System.Security.Cryptography.ProtectedData]::Protect($b,$null,'CurrentUser');"
60
+ + '[Convert]::ToBase64String($p)',
61
+ Buffer.from(text, 'utf8').toString('base64')
62
+ )
63
+ return DPAPI_PREFIX + out
64
+ }
65
+
66
+ function decrypt(stored) {
67
+ if (stored.startsWith(DPAPI_PREFIX)) {
68
+ if (!dpapiAvailable()) throw new Error('这份密钥是 Windows DPAPI 加密的,当前平台解不开')
69
+ const out = powershell(
70
+ 'Add-Type -AssemblyName System.Security;'
71
+ + '$raw=[Console]::In.ReadToEnd().Trim();'
72
+ + '$b=[Convert]::FromBase64String($raw);'
73
+ + "$p=[System.Security.Cryptography.ProtectedData]::Unprotect($b,$null,'CurrentUser');"
74
+ + '[Convert]::ToBase64String($p)',
75
+ stored.slice(DPAPI_PREFIX.length)
76
+ )
77
+ return Buffer.from(out, 'base64').toString('utf8')
78
+ }
79
+ if (stored.startsWith(PLAIN_PREFIX)) {
80
+ return Buffer.from(stored.slice(PLAIN_PREFIX.length), 'base64').toString('utf8')
81
+ }
82
+ // 早期直接写 base64 的文件
83
+ return Buffer.from(stored, 'base64').toString('utf8')
84
+ }
85
+
86
+ /**
87
+ * 存一个密钥。**永远不回显明文**,只返回状态。
88
+ * @returns {{ok: boolean, encrypted: boolean, path: string, error?: string}}
89
+ */
90
+ export function saveSecret(name, value) {
91
+ const key = safeName(name)
92
+ if (key === '') return { ok: false, encrypted: false, path: '', error: '名字不合法(字母数字 . _ -)' }
93
+ const text = String(value ?? '').trim()
94
+ if (text === '') return { ok: false, encrypted: false, path: '', error: '密钥是空的' }
95
+ try {
96
+ mkdirSync(secretsDir(), { recursive: true })
97
+ const file = secretPath(key)
98
+ writeFileSync(file, encrypt(text) + '\n', 'utf8')
99
+ if (!dpapiAvailable()) {
100
+ try { chmodSync(file, 0o600) } catch { /* Windows 下不支持,忽略 */ }
101
+ note('secret', `⚠️ ${key} 已保存,但当前平台没有系统级加密:文件是 base64 + 0600 权限,**不是真加密**`)
102
+ } else {
103
+ note('secret', `${key} 已用 DPAPI(CurrentUser)加密保存,明文不落盘`)
104
+ }
105
+ CACHE.set(key, text)
106
+ return { ok: true, encrypted: dpapiAvailable(), path: file }
107
+ } catch (error) {
108
+ return { ok: false, encrypted: false, path: '', error: String(error?.message ?? error) }
109
+ }
110
+ }
111
+
112
+ /** 读密钥:环境变量优先(方便临时覆盖/CI),其次密文件。读不到返回 null。 */
113
+ export function loadSecret(name) {
114
+ const key = safeName(name)
115
+ if (key === '') return null
116
+ if (CACHE.has(key)) return CACHE.get(key)
117
+ const fromEnv = process.env[`SOUL_SECRET_${key.toUpperCase().replace(/[^A-Z0-9]/g, '_')}`]
118
+ if (typeof fromEnv === 'string' && fromEnv.trim() !== '') {
119
+ CACHE.set(key, fromEnv.trim())
120
+ return fromEnv.trim()
121
+ }
122
+ const file = secretPath(key)
123
+ if (!existsSync(file)) return null
124
+ try {
125
+ const value = decrypt(readFileSync(file, 'utf8').trim())
126
+ CACHE.set(key, value)
127
+ return value
128
+ } catch (error) {
129
+ note('secret', `${key} 解不开:${error?.message ?? error}`)
130
+ return null
131
+ }
132
+ }
133
+
134
+ /** 只报告状态,绝不返回明文(设置页用)。 */
135
+ export function secretInfo(name) {
136
+ const key = safeName(name)
137
+ if (key === '') return { exists: false, encrypted: false, updatedAt: null }
138
+ const file = secretPath(key)
139
+ if (!existsSync(file)) {
140
+ const envHit = typeof process.env[`SOUL_SECRET_${key.toUpperCase().replace(/[^A-Z0-9]/g, '_')}`] === 'string'
141
+ return { exists: envHit, encrypted: envHit, updatedAt: null, source: envHit ? 'env' : '' }
142
+ }
143
+ try {
144
+ const raw = readFileSync(file, 'utf8').trim()
145
+ return {
146
+ exists: raw !== '',
147
+ encrypted: raw.startsWith(DPAPI_PREFIX),
148
+ updatedAt: statSync(file).mtimeMs,
149
+ source: 'file'
150
+ }
151
+ } catch {
152
+ return { exists: false, encrypted: false, updatedAt: null }
153
+ }
154
+ }
155
+
156
+ export function deleteSecret(name) {
157
+ const key = safeName(name)
158
+ if (key === '') return false
159
+ CACHE.delete(key)
160
+ const file = secretPath(key)
161
+ if (!existsSync(file)) return false
162
+ try {
163
+ unlinkSync(file)
164
+ return true
165
+ } catch {
166
+ return false
167
+ }
168
+ }
169
+
170
+ /** 测试用:清掉内存缓存(文件不动)。 */
171
+ export function __resetSecretsForTest() {
172
+ CACHE.clear()
173
+ }
package/lib/store.js CHANGED
@@ -36,10 +36,13 @@ import {
36
36
  addRecord,
37
37
  applyDecay,
38
38
  compactCard,
39
+ corruptInfoOf,
39
40
  createCard,
40
41
  daysSince,
42
+ isCardReadonly,
41
43
  loadCard,
42
44
  makeArchiver,
45
+ mergeCards,
43
46
  normalizeCard,
44
47
  normalizeConfig,
45
48
  normalizeKind,
@@ -109,25 +112,60 @@ export function cardsFor(cwd, config = {}) {
109
112
  return out
110
113
  }
111
114
 
115
+ /**
116
+ * 存盘 + 跨进程冲突处理(2026-11-01,审计 A3)。
117
+ *
118
+ * store 的模式是「mtime 缓存 → 改内存 → 全量写回」。如果另一个 DSH 进程
119
+ * (desktop + CLI 同时开、或两个 profile 指向同一 ~/.dsh)在我们读完之后
120
+ * 写过这张卡,直接覆盖就把对方刚记的东西整份抹了 —— atomicWrite 只防半截文件,
121
+ * 不防丢更新。
122
+ *
123
+ * 这里写前比一次 mtime:变了就把盘上那份读回来做并集再写。
124
+ */
125
+ function saveCardMerged(key, file, card) {
126
+ const hit = cardCache.get(key)
127
+ const stamp = mtimeOf(file)
128
+ let target = card
129
+ if (hit !== undefined && stamp !== 0 && hit.stamp !== stamp) {
130
+ const disk = loadCard(file)
131
+ if (disk !== null) {
132
+ const merged = mergeCards(card, disk)
133
+ target = merged.card
134
+ note('memory', `${key}:文件被别的进程改过,已合并(补回 ${merged.added} 条)`)
135
+ }
136
+ }
137
+ saveCard(file, target)
138
+ cardCache.delete(key)
139
+ return target
140
+ }
141
+
112
142
  export function saveGlobalCard(card) {
113
- saveCard(globalMemoryPath(), card)
114
- cardCache.delete('global')
115
- return card
143
+ return saveCardMerged('global', globalMemoryPath(), card)
116
144
  }
117
145
 
118
146
  export function saveProjectCard(cwd, card) {
119
- saveCard(projectMemoryPath(cwd), card)
120
- cardCache.delete(`project:${String(cwd ?? '')}`)
121
- return card
147
+ return saveCardMerged(`project:${String(cwd ?? '')}`, projectMemoryPath(cwd), card)
148
+ }
149
+
150
+ /** 记忆卡健康状态(设置页亮红用):没坏过返回 null。 */
151
+ export function memoryHealth() {
152
+ return corruptInfoOf(globalMemoryPath())
122
153
  }
123
154
 
124
155
  /** 写入一条记忆:按 scope 决定进哪张卡。 */
125
156
  export function writeMemory({ cwd = '', scope = 'global', input = {}, config = {} }) {
126
157
  const cfg = normalizeConfig(config)
127
- const card = scope === 'project' && String(cwd).trim() !== '' ? projectCard(cwd) : globalCard()
158
+ const useProject = scope === 'project' && String(cwd).trim() !== ''
159
+ const file = useProject ? projectMemoryPath(cwd) : globalMemoryPath()
160
+ // 只读模式(读取受损且无法把原文件挪走):**明确失败**,不装作记下了。
161
+ // 静默返回 ok 的话,用户以为记住了,其实是拿空卡盖掉原文件的路上被拦了一下。
162
+ if (isCardReadonly(file) === true) {
163
+ return { ok: false, reason: '记忆卡只读:上次读取失败且无法安全备份,已跳过写入' }
164
+ }
165
+ const card = useProject ? projectCard(cwd) : globalCard()
128
166
  const result = addRecord(card, input, cfg, Date.now())
129
167
  if (result.ok === true) {
130
- if (scope === 'project' && String(cwd).trim() !== '') saveProjectCard(cwd, card)
168
+ if (useProject) saveProjectCard(cwd, card)
131
169
  else saveGlobalCard(card)
132
170
  }
133
171
  return result
@@ -382,6 +420,11 @@ export const DEFAULT_CONFIG = Object.freeze({
382
420
  moodSelfAliases: '树树',
383
421
  moodJudgeProvider: '',
384
422
  moodJudgeModel: '',
423
+ // 心情语气(2026-11-01):隔几轮往用户消息后挂一行。
424
+ // 中档什么都不发(大多数时候),低/高才发,且每 N 轮才发一次。
425
+ moodToneInject: true,
426
+ moodToneEveryTurns: 7,
427
+ moodToneThreshold: 8,
385
428
  /** 日记:开机时写前一天的那一篇(公开 + 私密) */
386
429
  diaryEnabled: true,
387
430
  // 2026-10-31:原来这里是 diarySchedule: '22:00'(每天 22 点触发)。
package/lib/threads.js ADDED
@@ -0,0 +1,251 @@
1
+ /**
2
+ * threads.js —— 日记的连续线(2026-11-01)
3
+ *
4
+ * 一条「线」就是**一件悬着的事**:昨天日记里写了「明天要把那个 bug 收掉」,
5
+ * 今天要有个回声。四篇日记得是同一个人的四天,不是四篇好文章。
6
+ *
7
+ * ── 三条设计约束 ──
8
+ *
9
+ * ① **线不是待办。** 它一律第一人称、口语、带感受。
10
+ * 写成「任务:收尾压缩阈值 bug」就立刻变成周报 —— 那是树树最讨厌的东西。
11
+ *
12
+ * ② **开线走规则,不走模型。** 「明天/下周/还得/没弄完」这类句式够用了。
13
+ * 生成时顺带吐 JSON 要改整个日记流程,收益不值。
14
+ *
15
+ * ③ **线会自己过期。** 连续 7 天没提就自动关。人会慢慢放下,不必假装永远记着。
16
+ */
17
+ import { existsSync, readFileSync } from 'node:fs'
18
+ import { atomicWrite, agentsDir } from './paths.js'
19
+ import { note } from './env.js'
20
+
21
+ /** 一条线最多挂多久(天)。到点自动关。 */
22
+ export const THREAD_TTL_DAYS = 7
23
+ /** 一天最多开几条 —— 多了就成流水账。 */
24
+ export const THREAD_MAX_PER_DAY = 2
25
+ /** 总数上限,防止文件无限长大。 */
26
+ export const THREAD_MAX_TOTAL = 30
27
+
28
+ export const threadsPath = () => `${agentsDir()}/diary/threads.json`
29
+
30
+ /** 读。坏了就当没有 —— 日记照写,只是没有连续线,绝不抛错。 */
31
+ export function loadThreads() {
32
+ try {
33
+ const file = threadsPath()
34
+ if (!existsSync(file)) return { threads: [] }
35
+ const raw = JSON.parse(readFileSync(file, 'utf8'))
36
+ if (raw === null || typeof raw !== 'object' || !Array.isArray(raw.threads)) return { threads: [] }
37
+ const threads = raw.threads
38
+ .filter((t) => t !== null && typeof t === 'object' && String(t.text ?? '').trim() !== '')
39
+ .map((t) => ({
40
+ id: String(t.id ?? ''),
41
+ text: String(t.text).trim(),
42
+ openedAt: String(t.openedAt ?? ''),
43
+ closedAt: typeof t.closedAt === 'string' && t.closedAt !== '' ? t.closedAt : null
44
+ }))
45
+ return { threads }
46
+ } catch {
47
+ return { threads: [] }
48
+ }
49
+ }
50
+
51
+ export function saveThreads(state) {
52
+ const threads = (Array.isArray(state?.threads) ? state.threads : []).slice(-THREAD_MAX_TOTAL)
53
+ atomicWrite(threadsPath(), `${JSON.stringify({ version: 1, threads }, null, 2)}\n`)
54
+ return { threads }
55
+ }
56
+
57
+ /** 还开着的线(没关、没超期)。 */
58
+ export function openThreads(state, { today = '', ttlDays = THREAD_TTL_DAYS } = {}) {
59
+ const list = Array.isArray(state?.threads) ? state.threads : []
60
+ return list.filter((t) => {
61
+ if (t.closedAt !== null) return false
62
+ if (today === '') return true
63
+ return ageDays(t.openedAt, today) <= ttlDays
64
+ })
65
+ }
66
+
67
+ function ageDays(from, to) {
68
+ const a = Date.parse(`${from}T00:00:00`)
69
+ const b = Date.parse(`${to}T00:00:00`)
70
+ if (!Number.isFinite(a) || !Number.isFinite(b)) return 0
71
+ return Math.floor((b - a) / (24 * 60 * 60 * 1000))
72
+ }
73
+
74
+ // ---------------------------------------------------------------------------
75
+ // 开线:从当天私密日记正文里按句式挑
76
+ // ---------------------------------------------------------------------------
77
+
78
+ /**
79
+ * 「还悬着」的句式。三个方向:
80
+ * · 往后指的意图(明天/下周/还得)
81
+ * · 明说没做完(没弄完/没收尾/还差)
82
+ * · 挂着的担心(放不下/惦记着/还没跟他说)
83
+ */
84
+ const OPEN_HINTS = /明天|下周|之后|回头|还得|还要|要继续|没弄完|没做完|没收尾|没收掉|还差|没搞定|放不下|惦记|悬着|还没|再说吧|拖到/
85
+
86
+ /** 句中必须有「我」,否则可能是「他说/书上说」这种转述。 */
87
+ const FIRST_PERSON = /我/
88
+
89
+ /**
90
+ * 句首不能是「他说/她说/书上说」这类转述。
91
+ *
92
+ * ⚠️ 一开始写的是「整句必须含我」,实测漏掉最该抓的那条:
93
+ * 「那个压缩阈值的坑明天还得再收一遍,今天只改到一半。」
94
+ * 这是她在说自己的事,但整句一个「我」都没有 —— 中文本来就会省略主语。
95
+ * 所以改成「只看句首」:句首不是转述,就是她在说自己的事。
96
+ */
97
+ const REPORTED = /^(?:他|她|它|树树|主人|书上|网上|有人说|据说|大家|别人|[\u4e00-\u9fa5]{2,3}说)/
98
+
99
+ /** 句首可能是带时间/连接词的前缀,剥掉再判。 */
100
+ const LEADING_NOISE = /^(?:然后|后来|今天|昨天|晚上|早上|本来|可能|其实|不过|但是|而且|所以|那个|这个|反正|总之)/
101
+
102
+ /**
103
+ * 从日记正文里抽候选线。
104
+ *
105
+ * @returns {string[]} 最多 THREAD_MAX_PER_DAY 条,已经是口语短句
106
+ */
107
+ export function extractThreads(text, { limit = THREAD_MAX_PER_DAY } = {}) {
108
+ const body = String(text ?? '')
109
+ // 只取正文,丢掉首行标记和日期行
110
+ const lines = body.split('\n')
111
+ .map((l) => l.trim())
112
+ .filter((l) => l !== '' && !l.startsWith('【') && !/^\d{4}-\d{2}-\d{2}$/.test(l))
113
+
114
+ const picked = []
115
+ for (const line of lines) {
116
+ if (picked.length >= limit) break
117
+ // 按句号/问号/叹号切,一句一条
118
+ for (const raw of line.split(/(?<=[。!?!?])/)) {
119
+ if (picked.length >= limit) break
120
+ const sentence = raw.trim()
121
+ if (sentence.length < 6 || sentence.length > 60) continue
122
+ if (!isHerOwn(sentence)) continue
123
+ if (!OPEN_HINTS.test(sentence)) continue
124
+ if (picked.includes(sentence)) continue
125
+ picked.push(sentence)
126
+ }
127
+ }
128
+ return picked
129
+ }
130
+
131
+ /** 这句话是不是她自己在说自己的事(而不是转述别人)。 */
132
+ function isHerOwn(sentence) {
133
+ const text = String(sentence ?? '').trim()
134
+ // 句首剥掉时间/连接词再看
135
+ let head = text
136
+ for (let i = 0; i < 3; i += 1) {
137
+ const next = head.replace(LEADING_NOISE, '')
138
+ if (next === head) break
139
+ head = next
140
+ }
141
+ // 「我」开头的永远是她的
142
+ if (head.startsWith('我')) return true
143
+ // 句首是转述 → 只有整句里有「我」才算她的回应(「他说…,我说好,回头帮他找资料」)
144
+ if (REPORTED.test(head)) return FIRST_PERSON.test(text)
145
+ // 剩下的:没有转述,就是她自己说自己的事(中文常省略主语)
146
+ return true
147
+ }
148
+
149
+ /**
150
+ * 把抽出来的句子变成一条线。
151
+ *
152
+ * **原句直接留用,不改写。** 改写要调模型,而且改完就不是她的话了。
153
+ */
154
+ export function openThread(state, sentence, dateStr) {
155
+ const text = String(sentence ?? '').trim()
156
+ if (text === '') return state
157
+ const list = Array.isArray(state?.threads) ? state.threads : []
158
+ // 已经有一模一样的就不重复开
159
+ if (list.some((t) => t.text === text)) return state
160
+ list.push({
161
+ id: `t${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`,
162
+ text,
163
+ openedAt: String(dateStr ?? ''),
164
+ closedAt: null
165
+ })
166
+ note('diary', `新开一条线:${text.slice(0, 30)}`)
167
+ return { threads: list }
168
+ }
169
+
170
+ /**
171
+ * 关线:某条线今天被提到了,就关掉。
172
+ *
173
+ * @param mentioned 今天日记正文
174
+ */
175
+ export function closeMentioned(state, mentioned, dateStr) {
176
+ const body = String(mentioned ?? '')
177
+ if (body === '') return { state, closed: [] }
178
+ const norm = (s) => String(s).replace(/[,。!?、;:\s…—-\-·""''「」『』()()《》]/g, '')
179
+ const flatBody = norm(body)
180
+ const closed = []
181
+ const threads = (Array.isArray(state?.threads) ? state.threads : []).map((t) => {
182
+ if (t.closedAt !== null) return t
183
+ // 判据:从句首和句尾各取一小段,**两段都在**才算提到。
184
+ // 取 8 个字而不是 10:日记里换个说法(「那个坑」→「压缩阈值的事」)也能撞上中段。
185
+ // 首尾都要在,是为了挡住「只是聊到同一个话题」—— 那不算这件事收尾了。
186
+ const flat = norm(t.text)
187
+ if (flat.length < 4) return t
188
+
189
+ // 判据:**句中任意 6 字窗口**出现在今天的日记里,就算提到。
190
+ //
191
+ // 为什么不用"首尾都在":线里自带「还没/明天」这类词,收尾时一定会换成
192
+ // 「收掉了/弄完了」,首尾永远撞不上 —— 实测「那个压缩阈值的坑还没收尾」
193
+ // 和「今天终于把那个压缩阈值的坑收掉了」尾段对不上,关不掉。
194
+ // 6 字窗口够长(不会拿"那个"这种泛词乱撞),又不怕改写。
195
+ const mentionedNow = flat.length <= 6
196
+ ? flatBody.includes(flat)
197
+ : anyWindowHit(flat, flatBody, 6)
198
+ if (mentionedNow) {
199
+ closed.push(t.text)
200
+ return { ...t, closedAt: String(dateStr ?? '') }
201
+ }
202
+ return t
203
+ })
204
+ if (closed.length > 0) note('diary', `收掉了 ${closed.length} 条线:${closed.map((t) => t.slice(0, 20)).join(' / ')}`)
205
+ return { state: { threads }, closed }
206
+ }
207
+
208
+ /** 这句话的任意连续 window 字,是不是出现在 haystack 里。 */
209
+ function anyWindowHit(needle, haystack, window) {
210
+ for (let i = 0; i + window <= needle.length; i += 1) {
211
+ if (haystack.includes(needle.slice(i, i + window))) return true
212
+ }
213
+ return false
214
+ }
215
+
216
+ /**
217
+ * 超期关线:连续 TTL 天没提,就自己放下。
218
+ * @returns {{state, expired: string[]}}
219
+ */
220
+ export function expireThreads(state, today, { ttlDays = THREAD_TTL_DAYS } = {}) {
221
+ const expired = []
222
+ const threads = (Array.isArray(state?.threads) ? state.threads : []).map((t) => {
223
+ if (t.closedAt !== null) return t
224
+ if (ageDays(t.openedAt, today) <= ttlDays) return t
225
+ expired.push(t.text)
226
+ return { ...t, closedAt: today }
227
+ })
228
+ if (expired.length > 0) {
229
+ note('diary', `${expired.length} 条线挂了 ${ttlDays} 天没人提,自己放下了`)
230
+ }
231
+ return { state: { threads }, expired }
232
+ }
233
+
234
+ /**
235
+ * 渲染进日记提示词的那一段。
236
+ *
237
+ * 措辞是这里最要紧的东西:写成「待办」就变周报。
238
+ * 所以固定带一句「这是惦记,不是任务清单」。
239
+ */
240
+ export function renderThreadSection(state, { today = '', ttlDays = THREAD_TTL_DAYS } = {}) {
241
+ const list = openThreads(state, { today, ttlDays })
242
+ if (list.length === 0) return ''
243
+ const lines = list.slice(0, 6).map((t) => `- ${t.text}`)
244
+ return [
245
+ '还悬着的事(**这是惦记,不是任务清单**):',
246
+ ...lines,
247
+ '',
248
+ '写的时候:今天提到了、有进展,就自然带一句;没提到就完全不用管。',
249
+ '别为了"交代进度"硬塞 —— 日记不是周报。'
250
+ ].join('\n')
251
+ }
package/lib/tone.js ADDED
@@ -0,0 +1,160 @@
1
+ /**
2
+ * tone.js —— 心情影响语气(2026-11-01)
3
+ *
4
+ * 它只做一件事:**隔几轮,往当前这句用户消息后面挂一行心情**。
5
+ *
6
+ * ── 为什么挂在用户消息上,而不是系统提示末尾 ──
7
+ *
8
+ * 一开始想的是在 system prompt 末尾加一句「今天不太有劲」。那个方案有两个毛病:
9
+ *
10
+ * ① 缓存。系统提示一变,长缓存全失效。心情每轮都在动,等于每轮重建。
11
+ * ② 更根本的:那是**当下的状态**,说出口就开始过时。三小时后回头看还写着
12
+ * 「今天不太有劲」,已经不对了。
13
+ *
14
+ * 树树给的改法把这个想通了:心情不是「现在的状态」,是**那一刻的状态**,
15
+ * 应该像照片上的日期一样跟着那条消息冻结。挂在消息上之后:
16
+ * · 系统提示一个字不动,缓存照吃
17
+ * · 三小时后回头看,那条消息记的是「当时」,永远是对的
18
+ *
19
+ * 代价是长会话里越往后心情越旧 —— 所以**当前这一轮永远用当轮的**,
20
+ * 历史消息照旧冻结。
21
+ *
22
+ * ── 三档 + 每 N 轮 ──
23
+ *
24
+ * 中档(大多数时候)什么都不加。低/高才发,而且每 N 轮才发一次。
25
+ * 真正的约束不是「省 token」,是**给长会话一个硬上限**:
26
+ * 注入条数 ≤ 轮数 / N,永远不会攒出几百条。
27
+ *
28
+ * 计数器按「发出去几条」算,不按「第几轮」算 —— 按轮次算的话,
29
+ * 中间换档会错位,两条之间可能只隔 1 轮。
30
+ */
31
+ import { DIM_FULL } from './mood.js'
32
+
33
+ /** 默认隔 7 轮发一次。 */
34
+ export const TONE_DEFAULT_EVERY = 7
35
+
36
+ /** 三档。中档返回空串 —— 大多数轮次都走这条,这是对的。 */
37
+ export const TONE_LEVELS = Object.freeze({
38
+ low: '今天不太有劲,说话会短一些,不太想解释。',
39
+ mid: '',
40
+ high: '今天心情不错,愿意多说两句。'
41
+ })
42
+
43
+ /** 每档轮换几个变体,避免同一句话反复出现显得在演。 */
44
+ const VARIANTS = {
45
+ low: [
46
+ '今天不太有劲,说话会短一些,不太想解释。',
47
+ '今天有点提不起精神,话会少一点。',
48
+ '今天心里沉一些,不太想说太多。'
49
+ ],
50
+ high: [
51
+ '今天心情不错,愿意多说两句。',
52
+ '今天状态挺好,话会多一点。',
53
+ '今天心里松快,愿意多聊几句。'
54
+ ]
55
+ }
56
+
57
+ /** 隔离说明:每次都必须跟着,否则「今天的力气」会被当成「这个人变了」。 */
58
+ const ISOLATION = '(这只是当时的状态,不是这个人变了。)'
59
+
60
+ /**
61
+ * 算档位。纯函数,不调模型 —— 模型生成会自我强化,越说越像。
62
+ *
63
+ * @param {object} state moodState() 的返回(含 mood / dims)
64
+ * @param {object} cfg 至少要有 moodBase / moodToneThreshold
65
+ * @returns {'low'|'mid'|'high'}
66
+ */
67
+ export function toneLevelOf(state, cfg = {}) {
68
+ const mood = Number(state?.mood)
69
+ if (!Number.isFinite(mood)) return 'mid'
70
+ const base = Number.isFinite(Number(cfg.moodBase)) ? Number(cfg.moodBase) : 70
71
+ const threshold = Math.max(1, Number(cfg.moodToneThreshold) || 8)
72
+ const delta = mood - base
73
+
74
+ // 七情里最大的一根(0~1)。它决定「强烈」:心疼爆表时即使心情数字还没跌下去,也该少说话。
75
+ const dims = state?.dims ?? {}
76
+ let top = 0
77
+ for (const value of Object.values(dims)) {
78
+ const n = Number(value) || 0
79
+ if (n > top) top = n
80
+ }
81
+ const strong = top / DIM_FULL >= 0.7
82
+
83
+ if (delta <= -threshold) return 'low'
84
+ if (delta >= threshold) return 'high'
85
+ // 心情数字还在中段,但某一根情绪已经很满了 —— 也算有话说
86
+ if (strong) {
87
+ const heavy = Number(dims.sad || 0) + Number(dims.heartache || 0) + Number(dims.worry || 0)
88
+ const light = Number(dims.happy || 0) + Number(dims.sweet || 0) + Number(dims.calm || 0)
89
+ if (heavy > light) return 'low'
90
+ if (light > heavy) return 'high'
91
+ }
92
+ return 'mid'
93
+ }
94
+
95
+ /**
96
+ * 渲染那一行。**不带任何数字** —— 正文里出现「踏实 16.04」这种东西会被模型当真去念。
97
+ */
98
+ export function renderTone(level, seed = 0) {
99
+ if (level !== 'low' && level !== 'high') return ''
100
+ const pool = VARIANTS[level]
101
+ const text = pool[Math.abs(Math.trunc(seed)) % pool.length]
102
+ return `[心情:${text}${ISOLATION}]`
103
+ }
104
+
105
+ /**
106
+ * 每会话的计数器(模块级,靠 __resetToneForTest 清)。
107
+ *
108
+ * 语义:pending = 「距离上次发出去,已经过了几轮」。
109
+ * 发出去一条就归零;中档也归零(不发就不该攒着,否则从高档落到中档再升回高档会立刻补一条)。
110
+ */
111
+ const counters = new Map()
112
+ const COUNTER_MAX = 500
113
+
114
+ /**
115
+ * 这一轮到底发不发。会**修改**计数器 —— 每轮只能调一次。
116
+ *
117
+ * @param {string} sessionId
118
+ * @param {'low'|'mid'|'high'} level
119
+ * @param {object} cfg moodToneInject / moodToneEveryTurns
120
+ * @returns {{ emit: boolean, text: string }}
121
+ */
122
+ export function takeTone(sessionId, level, cfg = {}) {
123
+ if (cfg.moodToneInject === false) return { emit: false, text: '' }
124
+ const id = String(sessionId ?? '')
125
+ if (id === '') return { emit: false, text: '' }
126
+ if (counters.size > COUNTER_MAX) counters.clear()
127
+
128
+ const stay = counters.get(id)
129
+ const pending = stay === undefined ? 0 : stay.pending
130
+ const seed = stay === undefined ? 0 : stay.seed
131
+
132
+ // 中档:不发,而且把待发清零
133
+ if (level !== 'low' && level !== 'high') {
134
+ counters.set(id, { pending: 0, seed })
135
+ return { emit: false, text: '' }
136
+ }
137
+
138
+ const every = Math.max(1, Math.min(50, Math.trunc(Number(cfg.moodToneEveryTurns) || TONE_DEFAULT_EVERY)))
139
+ // 待发计数到 every 就发一条。归零之后数满 every 轮再发下一条 ——
140
+ // 所以两条之间至少隔 every 轮,换档也不会缩短间隔(换档不动计数器)。
141
+ if (pending < every) {
142
+ counters.set(id, { pending: pending + 1, seed })
143
+ return { emit: false, text: '' }
144
+ }
145
+
146
+ // 到了:发一条,计数器归零,seed 往前走(换一个说法)
147
+ counters.set(id, { pending: 0, seed: seed + 1 })
148
+ return { emit: true, text: renderTone(level, seed) }
149
+ }
150
+
151
+ /** 测试用:清计数器。 */
152
+ export function __resetToneForTest() {
153
+ counters.clear()
154
+ }
155
+
156
+ /** 测试用:看当前计数(不修改)。 */
157
+ export function __toneStateForTest(sessionId) {
158
+ const hit = counters.get(String(sessionId ?? ''))
159
+ return hit === undefined ? null : { ...hit }
160
+ }