dsh-lifecard 0.2.2 → 0.4.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/README.md +4 -4
- package/cordis.patch.yml +65 -1
- package/lib/career.js +98 -0
- package/lib/client.js +1159 -39
- package/lib/core.js +23 -3
- package/lib/diary.js +838 -0
- package/lib/index.js +644 -10
- package/lib/novel.js +1508 -2
- package/lib/presets.js +30 -0
- package/lib/store.js +98 -12
- package/lib/tavern.js +3 -0
- package/lifecard-tools.js +534 -59
- package/package.json +2 -1
- package/skills/lifecard-diary/SKILL.md +131 -0
- package/skills/novel-to-script/SKILL.md +103 -0
package/lib/index.js
CHANGED
|
@@ -20,6 +20,7 @@ import * as codec from './codec.js'
|
|
|
20
20
|
import * as store from './store.js'
|
|
21
21
|
import * as prose from './prose.js'
|
|
22
22
|
import * as prompts from './prompts.js'
|
|
23
|
+
import * as diary from './diary.js'
|
|
23
24
|
|
|
24
25
|
import * as score from './score.js'
|
|
25
26
|
import * as memory from './memory.js'
|
|
@@ -1037,6 +1038,7 @@ function buildApi(ctx, workspace, config, options) {
|
|
|
1037
1038
|
real: String(pins.real ?? ''),
|
|
1038
1039
|
tavern: String(pins.tavern ?? ''),
|
|
1039
1040
|
novel: String(pins.novel ?? ''),
|
|
1041
|
+
diary: String(pins.diary ?? ''),
|
|
1040
1042
|
},
|
|
1041
1043
|
}
|
|
1042
1044
|
},
|
|
@@ -1069,17 +1071,116 @@ function buildApi(ctx, workspace, config, options) {
|
|
|
1069
1071
|
'card.defaults.set': async (body) => {
|
|
1070
1072
|
const ws = await root(body)
|
|
1071
1073
|
const mode = String(body?.mode ?? '')
|
|
1072
|
-
if (mode !== 'real' && mode !== 'tavern' && mode !== 'novel') {
|
|
1074
|
+
if (mode !== 'real' && mode !== 'tavern' && mode !== 'novel' && mode !== 'diary') {
|
|
1073
1075
|
return { ok: false, error: '不知道你说的是哪扇门。' }
|
|
1074
1076
|
}
|
|
1075
1077
|
const id = String(body?.id ?? '').trim()
|
|
1076
1078
|
const cfg = await store.readConfigState(ws)
|
|
1077
1079
|
if (cfg.ok !== true) return { ok: false, error: cfg.error ?? '这个文件夹里的设置读不出来。' }
|
|
1078
|
-
const pins = { real: '', tavern: '', novel: '', ...(cfg.config?.default_cards ?? {}) }
|
|
1080
|
+
const pins = { real: '', tavern: '', novel: '', diary: '', ...(cfg.config?.default_cards ?? {}) }
|
|
1079
1081
|
pins[mode] = id
|
|
1080
|
-
await store.writeConfig(ws, { default_cards: pins })
|
|
1082
|
+
const saved = await store.writeConfig(ws, { default_cards: pins })
|
|
1083
|
+
if (saved?.ok !== true) return { ok: false, error: saved?.error ?? '这一张没能记住,下次还得再挑一次。', cards: pins }
|
|
1081
1084
|
return { ok: true, cards: pins }
|
|
1082
1085
|
},
|
|
1086
|
+
|
|
1087
|
+
/**
|
|
1088
|
+
* 人物关系网:以「我」为中心,把认识的人一圈一圈摆开。
|
|
1089
|
+
*
|
|
1090
|
+
* 这一版不做图,只把「谁是谁、离我多远、多亲」算清楚交给界面。
|
|
1091
|
+
* 距离的口径:
|
|
1092
|
+
* ring 0 = 我自己(kind self,或者老档案里 relation 写「我」的那张)
|
|
1093
|
+
* ring 1 = 直接写着和我有关系的人(他的 relation 是「父亲」「朋友」这种)
|
|
1094
|
+
* ring 2 = 只和某个 ring 1 的人有关系的人(比如「我姨」只和妈妈连着)
|
|
1095
|
+
* 没有任何关系线索的人不进网——放进去也只是一堆没有边的点。
|
|
1096
|
+
*/
|
|
1097
|
+
'relations.net': async (body) => {
|
|
1098
|
+
const ws = await root(body)
|
|
1099
|
+
const all = await store.listAll(ws)
|
|
1100
|
+
const cards = Array.isArray(all.cards) ? all.cards : []
|
|
1101
|
+
const edges = Array.isArray(all.relations) ? all.relations : []
|
|
1102
|
+
const labelOf = new Map(prompts.RELATION_TYPES.map((one) => [String(one.id), String(one.label)]))
|
|
1103
|
+
const selfCard = cards.find((c) => String(c.kind ?? '') === 'self')
|
|
1104
|
+
?? cards.find((c) => String(c.kind ?? '') === 'real' && String(c.relation ?? '').trim() === '我')
|
|
1105
|
+
?? null
|
|
1106
|
+
const selfId = selfCard === null ? '' : String(selfCard.id ?? '')
|
|
1107
|
+
const nodeOf = (c) => ({
|
|
1108
|
+
id: String(c.id ?? ''),
|
|
1109
|
+
name: String(c.name ?? '').trim() === '' ? '(还没起名字)' : String(c.name),
|
|
1110
|
+
kind: String(c.kind ?? 'real'),
|
|
1111
|
+
relation: String(c.relation ?? '').trim(),
|
|
1112
|
+
relationLabel: String(c.relation ?? '').trim() === ''
|
|
1113
|
+
? ''
|
|
1114
|
+
: (labelOf.get(String(c.relation).trim()) ?? String(c.relation).trim()),
|
|
1115
|
+
extras: Array.isArray(c.relation_extra) ? c.relation_extra.filter((x) => typeof x === 'string') : [],
|
|
1116
|
+
tags: Array.isArray(c.tags) ? c.tags : [],
|
|
1117
|
+
intro: String(c.intro ?? ''),
|
|
1118
|
+
coverage: Number(c.coverage ?? 0),
|
|
1119
|
+
path: String(c.path ?? ''),
|
|
1120
|
+
})
|
|
1121
|
+
|
|
1122
|
+
const rings = { 0: [], 1: [], 2: [] }
|
|
1123
|
+
const placed = new Map()
|
|
1124
|
+
if (selfCard !== null) {
|
|
1125
|
+
rings[0].push(nodeOf(selfCard))
|
|
1126
|
+
placed.set(selfId, 0)
|
|
1127
|
+
}
|
|
1128
|
+
// 第一轮:卡上自己写着关系的人,都算直接认识(ring 1)。
|
|
1129
|
+
// 这一轮得排在关系边前面——边只回答「再往外还有谁」,它得有落脚点;
|
|
1130
|
+
// 反过来先处理边,一圈还没人的时候边就没有起点可用,第 2 圈永远是空的。
|
|
1131
|
+
for (const card of cards) {
|
|
1132
|
+
const id = String(card.id ?? '')
|
|
1133
|
+
if (id === '' || placed.has(id)) continue
|
|
1134
|
+
const tag = String(card.relation ?? '').trim()
|
|
1135
|
+
if (tag === '' && String(card.kind ?? '') !== 'self') continue
|
|
1136
|
+
placed.set(id, 1)
|
|
1137
|
+
}
|
|
1138
|
+
// 第二轮:关系边再往外扩一层。两端都是 id,最准。
|
|
1139
|
+
// 只扩一层——再往外的人已经不是「我认识的人」,是「我认识的人认识的人」。
|
|
1140
|
+
for (const edge of edges) {
|
|
1141
|
+
const from = String(edge?.from ?? '')
|
|
1142
|
+
const to = String(edge?.to ?? '')
|
|
1143
|
+
if (from === '' || to === '') continue
|
|
1144
|
+
const depth = placed.get(from)
|
|
1145
|
+
if (depth !== undefined && depth < 2 && !placed.has(to)) placed.set(to, depth + 1)
|
|
1146
|
+
}
|
|
1147
|
+
const byId = new Map(cards.map((c) => [String(c.id ?? ''), c]))
|
|
1148
|
+
for (const [id, depth] of placed) {
|
|
1149
|
+
if (depth === 0) continue
|
|
1150
|
+
const card = byId.get(id)
|
|
1151
|
+
if (card === undefined) continue
|
|
1152
|
+
const node = nodeOf(card)
|
|
1153
|
+
// 越亲的越靠里:ring 2 里如果还带着「也是家人」这种补充关系,也算一回事。
|
|
1154
|
+
rings[depth].push(node)
|
|
1155
|
+
}
|
|
1156
|
+
rings[1].sort((a, b) => (b.coverage - a.coverage) || (a.name < b.name ? -1 : 1))
|
|
1157
|
+
rings[2].sort((a, b) => (b.coverage - a.coverage) || (a.name < b.name ? -1 : 1))
|
|
1158
|
+
|
|
1159
|
+
const inNet = new Set([...rings[0], ...rings[1], ...rings[2]].map((n) => n.id))
|
|
1160
|
+
// 网外的人不是「没有关系的人」,是「卡片在、还没写关系的人」。
|
|
1161
|
+
// 世界书、设定、偏好这几种根本不是人;虚构角色是「扮演用的角色」,
|
|
1162
|
+
// 不是认识的人——这一屏只在真实人物这扇门里给,混进来读着像出了错。
|
|
1163
|
+
// 真写了关系的(relation 非空)仍然进圈,因为那说明用户自己把她当成了一个人。
|
|
1164
|
+
const notPeople = new Set(['world', 'system', 'lens', 'relation', 'fictional'])
|
|
1165
|
+
const outside = cards
|
|
1166
|
+
.filter((c) => !inNet.has(String(c.id ?? '')))
|
|
1167
|
+
.filter((c) => !notPeople.has(String(c.kind ?? 'real')))
|
|
1168
|
+
.map((c) => ({
|
|
1169
|
+
id: String(c.id ?? ''),
|
|
1170
|
+
name: String(c.name ?? ''),
|
|
1171
|
+
kind: String(c.kind ?? 'real'),
|
|
1172
|
+
path: String(c.path ?? ''),
|
|
1173
|
+
}))
|
|
1174
|
+
|
|
1175
|
+
return {
|
|
1176
|
+
ok: true,
|
|
1177
|
+
self: selfCard === null ? null : nodeOf(selfCard),
|
|
1178
|
+
rings: { self: rings[0], inner: rings[1], outer: rings[2] },
|
|
1179
|
+
edges: edges.map((e) => ({ from: String(e.from ?? ''), to: String(e.to ?? ''), type: String(e.type ?? '') })),
|
|
1180
|
+
counts: { self: rings[0].length, inner: rings[1].length, outer: rings[2].length, outside: outside.length },
|
|
1181
|
+
outside,
|
|
1182
|
+
}
|
|
1183
|
+
},
|
|
1083
1184
|
/**
|
|
1084
1185
|
* 把一扇门从界面上收起来 / 装回来。
|
|
1085
1186
|
*
|
|
@@ -2917,7 +3018,12 @@ function buildApi(ctx, workspace, config, options) {
|
|
|
2917
3018
|
const ws = await root(body)
|
|
2918
3019
|
const id = String(body?.id ?? '').trim()
|
|
2919
3020
|
if (id === '') return { ok: false, error: '没有说是哪本书' }
|
|
2920
|
-
|
|
3021
|
+
const gone = await novel.deleteChapter(ws, id, body?.index)
|
|
3022
|
+
if (gone.ok !== true) return gone
|
|
3023
|
+
// 这一章没了,它上面那份剧本留着就是一份谁也点不到的孤儿——
|
|
3024
|
+
// 界面上只能按章翻,第 N 章都不存在了,那份剧本永远打不开也删不掉。
|
|
3025
|
+
const script = await novel.deleteScript(ws, id, body?.index)
|
|
3026
|
+
return script.ok === true ? gone : { ...gone, scriptKept: true }
|
|
2921
3027
|
},
|
|
2922
3028
|
|
|
2923
3029
|
/** 整本书不要了。 */
|
|
@@ -3184,6 +3290,82 @@ function buildApi(ctx, workspace, config, options) {
|
|
|
3184
3290
|
return { ok: true, target, text: String(called.text ?? '').trim() }
|
|
3185
3291
|
},
|
|
3186
3292
|
|
|
3293
|
+
/**
|
|
3294
|
+
* 从一张人物卡里把「能写进简历的东西」摘出来。
|
|
3295
|
+
*
|
|
3296
|
+
* 只摘不写:这一趟不碰简历文件。用户先看见摘了什么、来自哪一句,
|
|
3297
|
+
* 自己划掉不要的,再点一次才并进去。模型这一步只许抄原文,
|
|
3298
|
+
* 每条都要过逐字比对(捡不了就整条丢掉,不悄悄放宽)。
|
|
3299
|
+
*/
|
|
3300
|
+
'career.mine': async (body) => {
|
|
3301
|
+
const ws = await root(body); const mods = await ensureModules(); if (mods.career !== true) return missingFeature('career')
|
|
3302
|
+
const wanted = String(body?.card ?? '').trim()
|
|
3303
|
+
if (wanted === '') return { ok: false, error: '先挑一张卡。挑好我才能从里面往出摘。' }
|
|
3304
|
+
const rel = await store.findCardByRelOrId(ws, wanted)
|
|
3305
|
+
if (rel === null || rel === undefined) return { ok: false, error: `没找到「${wanted}」这张卡。` }
|
|
3306
|
+
const card = await store.readCard(ws, rel)
|
|
3307
|
+
if (card.ok !== true) return { ok: false, error: card.error ?? '这张卡读不出来。' }
|
|
3308
|
+
// 卡的正文才是材料。只拿 name 去问,模型只能靠猜。
|
|
3309
|
+
const text = String(card.text ?? '').trim()
|
|
3310
|
+
if (text === '') return { ok: false, error: '这张卡还是空的,里面没有能摘的东西。' }
|
|
3311
|
+
const name = String(card.data?.name ?? '').trim()
|
|
3312
|
+
const built = career.buildMinePrompt({ cardText: text, name })
|
|
3313
|
+
const called = await callModel(ctx, { system: built.system, user: built.user, model: body?.model })
|
|
3314
|
+
if (called.ok !== true) return { ok: false, error: `这次没摘出来:${called.error ?? '过一会儿再试一次'}` }
|
|
3315
|
+
const parsed = extractJson(called.text)
|
|
3316
|
+
if (parsed === null) return { ok: false, error: '这次回来的东西看不明白,再点一次试试。' }
|
|
3317
|
+
const raw = Array.isArray(parsed?.items) ? parsed.items : []
|
|
3318
|
+
// 材料表:材料名要和模型写的 evidence.material 对得上,这里只有一份,
|
|
3319
|
+
// 所以名字就叫这个(模型写全路径也认,verifyQuote 两头都能对上)。
|
|
3320
|
+
const materials = { [rel]: text }
|
|
3321
|
+
const kept = []
|
|
3322
|
+
const dropped = []
|
|
3323
|
+
for (const one of raw) {
|
|
3324
|
+
if (one === null || typeof one !== 'object') continue
|
|
3325
|
+
const slot = String(one.slot ?? '').trim()
|
|
3326
|
+
const line = String(one.text ?? '').trim()
|
|
3327
|
+
const quote = String(one.quote ?? '').trim()
|
|
3328
|
+
if (!career.MINE_SLOTS.includes(slot) || line === '') { dropped.push({ text: line, why: '这一条没说清放到哪儿' }); continue }
|
|
3329
|
+
const check = core.verifyQuote({ evidence: { material: rel, quote } }, materials)
|
|
3330
|
+
if (check.ok !== true) { dropped.push({ text: line, why: check.reason ?? '原文里找不到这一句' }); continue }
|
|
3331
|
+
kept.push({ slot, text: line, quote, line: check.line })
|
|
3332
|
+
}
|
|
3333
|
+
return {
|
|
3334
|
+
ok: true,
|
|
3335
|
+
card: { id: String(card.data?.id ?? ''), name, path: rel },
|
|
3336
|
+
groups: career.groupMined(kept),
|
|
3337
|
+
items: kept,
|
|
3338
|
+
dropped,
|
|
3339
|
+
labels: career.MINE_SLOT_LABELS,
|
|
3340
|
+
}
|
|
3341
|
+
},
|
|
3342
|
+
|
|
3343
|
+
/**
|
|
3344
|
+
* 把挑中的几条并进简历。只往后加,不改用户自己写的那几行。
|
|
3345
|
+
*
|
|
3346
|
+
* 为什么不在这里再调一次模型:摘出来的那一句就是要写进去的那一句。
|
|
3347
|
+
* 再让它「润色一下」,就会多出没发生过的细节。
|
|
3348
|
+
*/
|
|
3349
|
+
'career.merge': async (body) => {
|
|
3350
|
+
const ws = await root(body); const mods = await ensureModules(); if (mods.career !== true) return missingFeature('career')
|
|
3351
|
+
const rows = Array.isArray(body?.items) ? body.items : []
|
|
3352
|
+
const items = rows
|
|
3353
|
+
.map((one) => ({
|
|
3354
|
+
slot: String(one?.slot ?? '').trim(),
|
|
3355
|
+
text: String(one?.text ?? '').trim(),
|
|
3356
|
+
}))
|
|
3357
|
+
.filter((one) => career.MINE_SLOTS.includes(one.slot) && one.text !== '')
|
|
3358
|
+
if (items.length === 0) return { ok: false, error: '一条都没挑,那就没东西可并。' }
|
|
3359
|
+
const profile = await career.readProfile(ws)
|
|
3360
|
+
if (profile.ok !== true) return profile
|
|
3361
|
+
const mined = career.groupMined(items)
|
|
3362
|
+
const merged = career.mergeProfile(profile.sections ?? {}, mined)
|
|
3363
|
+
if (merged.added.length === 0) return { ok: true, added: 0, profile: merged.profile, note: '这几条简历里本来就有,没重复加。' }
|
|
3364
|
+
const saved = await career.writeProfile(ws, { ...(profile.data ?? {}), ...merged.profile })
|
|
3365
|
+
if (saved.ok !== true) return saved
|
|
3366
|
+
return { ok: true, added: merged.added.length, profile: merged.profile, path: saved.path }
|
|
3367
|
+
},
|
|
3368
|
+
|
|
3187
3369
|
/** 看差距:目标要求的 vs 你现在有的。 */
|
|
3188
3370
|
'career.gap': async (body) => {
|
|
3189
3371
|
const ws = await root(body); const mods = await ensureModules(); if (mods.career !== true) return missingFeature('career')
|
|
@@ -3214,6 +3396,207 @@ function buildApi(ctx, workspace, config, options) {
|
|
|
3214
3396
|
return { ok: true, goal, horizon, text, steps: career.parseSteps(text) }
|
|
3215
3397
|
},
|
|
3216
3398
|
|
|
3399
|
+
// ── 写日记:一天一篇,AI 带着写 ──────────────────────────────
|
|
3400
|
+
//
|
|
3401
|
+
// 日记不放在这个工作区里:第一次点「写日记」时问一句放哪儿,
|
|
3402
|
+
// 之后每天那篇就落在那里(见 diary_dir 配置)。这一层只做三件事:
|
|
3403
|
+
// 读写那一天的文件、拼出「今天该问什么」、把写下的东西整理成几条事实。
|
|
3404
|
+
|
|
3405
|
+
/** 日记文件夹在哪儿、今天写了没有。 */
|
|
3406
|
+
'diary.info': async (body) => {
|
|
3407
|
+
const ws = await root(body)
|
|
3408
|
+
const where = await diaryDirOf(ws)
|
|
3409
|
+
if (where.ok !== true) return where
|
|
3410
|
+
const today = store.localDate()
|
|
3411
|
+
// 第一次用的时候得给个能直接点的位置。客户端不知道用户家目录在哪儿
|
|
3412
|
+
// (宿主交给插件的作用域里没有这一层),所以在这儿算一句带回去。
|
|
3413
|
+
const suggested = path.join(homedir(), 'Documents', '我的日记')
|
|
3414
|
+
if (where.dir === '') return { ok: true, dir: '', ready: false, today, todayDone: false, count: 0, suggest: suggested, recent: [] }
|
|
3415
|
+
// 列最近 40 篇够看「今天写了没有」,但「写过多少天」得用总数报:
|
|
3416
|
+
// 拿列表长度当总数,写到第 401 天起数字就不动了。
|
|
3417
|
+
const listed = await diary.listDiaries(where.dir, { limit: 40 })
|
|
3418
|
+
// 文件夹被删掉 / 挪走 / 没权限时不能装作一切正常:用户会看到
|
|
3419
|
+
// 「今天还没写」,写的时候才发现存不进去。这两种情况如实说。
|
|
3420
|
+
if (listed.ok !== true) {
|
|
3421
|
+
return { ok: true, dir: where.dir, ready: true, today, todayDone: false, count: 0, recent: [], broken: true, error: listed.error ?? '那个文件夹读不出来。' }
|
|
3422
|
+
}
|
|
3423
|
+
const recent = listed.diaries.slice(0, 7)
|
|
3424
|
+
return {
|
|
3425
|
+
ok: true,
|
|
3426
|
+
dir: where.dir,
|
|
3427
|
+
ready: true,
|
|
3428
|
+
today,
|
|
3429
|
+
todayDone: recent.some((d) => d.date === today),
|
|
3430
|
+
count: Number(listed.total ?? listed.diaries.length),
|
|
3431
|
+
recent,
|
|
3432
|
+
missing: listed.missing === true,
|
|
3433
|
+
}
|
|
3434
|
+
},
|
|
3435
|
+
|
|
3436
|
+
/** 定下日记放哪儿(会顺手建好文件夹)。 */
|
|
3437
|
+
'diary.dir.set': async (body) => {
|
|
3438
|
+
const ws = await root(body)
|
|
3439
|
+
const raw = String(body?.dir ?? '').trim()
|
|
3440
|
+
if (raw === '') return { ok: false, error: '没有说是哪个文件夹。' }
|
|
3441
|
+
const dir = diary.diaryRootFrom({ diary_dir: raw })
|
|
3442
|
+
if (dir === '' || dir === path.parse(dir).root) return { ok: false, error: '不能整个磁盘根目录都当日记文件夹。换一个位置。' }
|
|
3443
|
+
const veto = diaryDirVeto(dir)
|
|
3444
|
+
if (veto !== '') return { ok: false, error: veto }
|
|
3445
|
+
const made = await fs.mkdir(dir, { recursive: true }).then(() => true).catch(() => false)
|
|
3446
|
+
if (!made) return { ok: false, error: '这个文件夹建不出来。换一个位置,或者检查一下有没有写的权限。' }
|
|
3447
|
+
// 探针文件用完就删,但**先看它原本存不存在**:用户文件夹里真有个同名文件时,
|
|
3448
|
+
// 我们既不该覆盖它,也不该删掉它。也不能给它传 undefined 当内容——
|
|
3449
|
+
// Node 对 `writeFile(p, undefined)` 直接抛 TypeError,于是「本来好好的文件夹」
|
|
3450
|
+
// 会被判成写不进去。
|
|
3451
|
+
const probe = path.join(dir, '.lifecard-diary-probe')
|
|
3452
|
+
const hadProbe = await fs.lstat(probe).then(() => true).catch(() => false)
|
|
3453
|
+
const writable = await (hadProbe
|
|
3454
|
+
? fs.appendFile(probe, '')
|
|
3455
|
+
: fs.writeFile(probe, 'x', { encoding: 'utf8' }).then(() => fs.rm(probe, { force: true }))
|
|
3456
|
+
).then(() => true).catch(() => false)
|
|
3457
|
+
if (writable !== true) return { ok: false, error: '这个文件夹写不进去。换一个位置,或者检查一下有没有写的权限。' }
|
|
3458
|
+
const saved = await store.writeConfig(ws, { diary_dir: dir })
|
|
3459
|
+
if (saved?.ok !== true) return { ok: false, error: saved?.error ?? '位置没记住,下次还得再挑一次。' }
|
|
3460
|
+
return { ok: true, dir }
|
|
3461
|
+
},
|
|
3462
|
+
|
|
3463
|
+
/** 读某一天(不传就是今天)。 */
|
|
3464
|
+
'diary.get': async (body) => {
|
|
3465
|
+
const ws = await root(body)
|
|
3466
|
+
const where = await diaryDirOf(ws)
|
|
3467
|
+
if (where.ok !== true) return where
|
|
3468
|
+
if (where.dir === '') return { ok: true, dir: '', ready: false, date: String(body?.date ?? '') || store.localDate(), data: null }
|
|
3469
|
+
const date = String(body?.date ?? '').trim() === '' ? store.localDate() : String(body.date).trim()
|
|
3470
|
+
if (diary.dateFileName(date) === '') return { ok: false, error: '日期看起来不对,应该是 2026-10-31 这种样子。' }
|
|
3471
|
+
const got = await diary.readDiary(where.dir, date)
|
|
3472
|
+
if (got.ok !== true) return got
|
|
3473
|
+
// 除了五节,还得把「文件里本来还有」的东西交出去:用户写在开头那段话、
|
|
3474
|
+
// 自己加的小节。不交的话界面上看不见它们,他会以为存丢了。
|
|
3475
|
+
return {
|
|
3476
|
+
ok: true,
|
|
3477
|
+
dir: where.dir,
|
|
3478
|
+
ready: true,
|
|
3479
|
+
date,
|
|
3480
|
+
data: got.data,
|
|
3481
|
+
intro: got.intro ?? '',
|
|
3482
|
+
extraSections: got.extraSections ?? [],
|
|
3483
|
+
scoreLines: got.scoreLines ?? [],
|
|
3484
|
+
missing: got.missing === true,
|
|
3485
|
+
}
|
|
3486
|
+
},
|
|
3487
|
+
|
|
3488
|
+
/** 存某一天。 */
|
|
3489
|
+
'diary.save': async (body) => {
|
|
3490
|
+
const ws = await root(body)
|
|
3491
|
+
const where = await diaryDirOf(ws)
|
|
3492
|
+
if (where.ok !== true) return where
|
|
3493
|
+
if (where.dir === '') return { ok: false, error: '还没有定日记放在哪个文件夹。' }
|
|
3494
|
+
const date = String(body?.date ?? '').trim() === '' ? store.localDate() : String(body.date).trim()
|
|
3495
|
+
if (diary.dateFileName(date) === '') return { ok: false, error: '日期看起来不对,应该是 2026-10-31 这种样子。' }
|
|
3496
|
+
// 先读一遍再写:写过的那一天,读出来是什么样,写的时候就得还是那个样子。
|
|
3497
|
+
// 中间被别处改过(用户自己在访达里动了),这次一个字节都不写。
|
|
3498
|
+
// 这条路由以前是裸写,谁调它都能把一整天整篇盖掉。
|
|
3499
|
+
const existing = await diary.readDiary(where.dir, date)
|
|
3500
|
+
if (existing.ok !== true) {
|
|
3501
|
+
return { ok: false, error: `这一天读不出来,为了不覆盖掉原来的东西,这次没存:${String(existing.error ?? '')}` }
|
|
3502
|
+
}
|
|
3503
|
+
const saved = await diary.writeDiary(where.dir, { ...(body?.data ?? {}), date }, new Date(), {
|
|
3504
|
+
expect: typeof existing.text === 'string' ? { text: existing.text } : {},
|
|
3505
|
+
})
|
|
3506
|
+
if (saved.ok !== true) return saved
|
|
3507
|
+
return { ok: true, dir: where.dir, date, path: saved.path, mode: saved.mode }
|
|
3508
|
+
},
|
|
3509
|
+
|
|
3510
|
+
/** 最近写过哪几天。 */
|
|
3511
|
+
'diary.list': async (body) => {
|
|
3512
|
+
const ws = await root(body)
|
|
3513
|
+
const where = await diaryDirOf(ws)
|
|
3514
|
+
if (where.ok !== true) return where
|
|
3515
|
+
if (where.dir === '') return { ok: true, dir: '', ready: false, diaries: [] }
|
|
3516
|
+
const listed = await diary.listDiaries(where.dir, { limit: Number(body?.limit) > 0 ? Number(body.limit) : 400 })
|
|
3517
|
+
if (listed.ok !== true) return listed
|
|
3518
|
+
return { ok: true, dir: where.dir, ready: true, diaries: listed.diaries }
|
|
3519
|
+
},
|
|
3520
|
+
|
|
3521
|
+
/**
|
|
3522
|
+
* 开今天这一场:给出预设名和第一句。
|
|
3523
|
+
*
|
|
3524
|
+
* 为什么不让客户端自己拼:要带上前几天写的、带着「我」那张卡里已经有的东西,
|
|
3525
|
+
* 还要知道今天写过没有。这些都只有后台读得到。
|
|
3526
|
+
*/
|
|
3527
|
+
'diary.start': async (body) => {
|
|
3528
|
+
const ws = await root(body)
|
|
3529
|
+
const where = await diaryDirOf(ws)
|
|
3530
|
+
if (where.ok !== true) return where
|
|
3531
|
+
const today = store.localDate()
|
|
3532
|
+
let recent = ''
|
|
3533
|
+
let todayDone = false
|
|
3534
|
+
let draft = ''
|
|
3535
|
+
if (where.dir !== '') {
|
|
3536
|
+
const listed = await diary.listDiaries(where.dir, { limit: 40 })
|
|
3537
|
+
if (listed.ok === true) {
|
|
3538
|
+
todayDone = listed.diaries.some((d) => d.date === today)
|
|
3539
|
+
// 今天已经写过的,把正文带上。不带的话模型看不见上午写的那几节,
|
|
3540
|
+
// 只好从头重问一遍;存盘时它照着新问出来的整节重写,上午写的就没了。
|
|
3541
|
+
if (todayDone) {
|
|
3542
|
+
const got = await diary.readDiary(where.dir, today)
|
|
3543
|
+
if (got.ok === true && got.data !== null) draft = diary.diaryBlock(got.data, { intro: got.intro, extraSections: got.extraSections })
|
|
3544
|
+
}
|
|
3545
|
+
const picked = listed.diaries.filter((d) => d.date !== today).slice(0, 3)
|
|
3546
|
+
const texts = []
|
|
3547
|
+
for (const item of picked) {
|
|
3548
|
+
const got = await diary.readDiary(where.dir, item.date)
|
|
3549
|
+
if (got.ok === true && got.data !== null) texts.push({ date: item.date, data: got.data, intro: got.intro, extraSections: got.extraSections })
|
|
3550
|
+
}
|
|
3551
|
+
recent = diary.recentBlock(picked.map((d) => d.date), texts)
|
|
3552
|
+
}
|
|
3553
|
+
}
|
|
3554
|
+
const pin = pinnedCardIdSync(ws, 'diary')
|
|
3555
|
+
let cardName = ''
|
|
3556
|
+
let persona = ''
|
|
3557
|
+
if (pin !== '') {
|
|
3558
|
+
const abs = cardPathSync(ws, pin)
|
|
3559
|
+
const raw = abs === '' ? null : readCachedSync(abs)
|
|
3560
|
+
if (raw !== null) {
|
|
3561
|
+
const parsed = core.parseCard(raw)
|
|
3562
|
+
if (parsed.ok === true) {
|
|
3563
|
+
cardName = String(parsed.data?.name ?? '').trim()
|
|
3564
|
+
persona = ['自述', '性格', '口癖', '不会说的话', '不会做的事']
|
|
3565
|
+
.map((title) => core.sectionBody(parsed.sections, title))
|
|
3566
|
+
.filter((part) => typeof part === 'string' && part.trim() !== '')
|
|
3567
|
+
.join('\n\n')
|
|
3568
|
+
}
|
|
3569
|
+
}
|
|
3570
|
+
}
|
|
3571
|
+
const text = [
|
|
3572
|
+
'/lifecard-diary',
|
|
3573
|
+
`今天是 ${today}。带我写今天这一篇。`,
|
|
3574
|
+
draft === '' ? '' : `\n今天已经写下这些了:\n${draft}`,
|
|
3575
|
+
draft === '' ? '' : '\n接着往下问,别把已经写过的重问一遍。要改哪一节先说清改成什么,我点头了再改。',
|
|
3576
|
+
persona === '' ? '' : `\n带着这张卡里的人来问(${cardName}):\n${persona}`,
|
|
3577
|
+
recent === '' ? '' : `\n前几天写过这些:\n${recent}`,
|
|
3578
|
+
]
|
|
3579
|
+
.filter((line) => line !== '')
|
|
3580
|
+
.join('\n')
|
|
3581
|
+
return { ok: true, preset: 'lc-diary', date: today, dir: where.dir, todayDone, cardName, personaChars: persona.length, draftChars: draft.length, text }
|
|
3582
|
+
},
|
|
3583
|
+
|
|
3584
|
+
/** 把某一天写下的东西整理成「关于这个人的几条事实」,给改卡用。 */
|
|
3585
|
+
'diary.digest': async (body) => {
|
|
3586
|
+
const ws = await root(body)
|
|
3587
|
+
const where = await diaryDirOf(ws)
|
|
3588
|
+
if (where.ok !== true) return where
|
|
3589
|
+
if (where.dir === '') return { ok: false, error: '还没有定日记放在哪个文件夹。' }
|
|
3590
|
+
const date = String(body?.date ?? '').trim() === '' ? store.localDate() : String(body.date).trim()
|
|
3591
|
+
const got = await diary.readDiary(where.dir, date)
|
|
3592
|
+
if (got.ok !== true) return got
|
|
3593
|
+
if (got.data === null) return { ok: false, error: '这一天还没写。' }
|
|
3594
|
+
const built = diary.buildDigestPrompt({ date, text: diary.diaryBlock(got.data, { intro: got.intro, extraSections: got.extraSections }) })
|
|
3595
|
+
const called = await callModel(ctx, { system: built.system, user: built.user, model: body?.model })
|
|
3596
|
+
if (called.ok !== true) return { ok: false, error: `这次没整理出来:${called.error ?? '过一会儿再试一次'}` }
|
|
3597
|
+
return { ok: true, date, text: String(called.text ?? '').trim() }
|
|
3598
|
+
},
|
|
3599
|
+
|
|
3217
3600
|
// ── 文字小说游戏:进到情节里,你来选,它来推 ────────────────
|
|
3218
3601
|
|
|
3219
3602
|
/** 一本书能开哪几局。 */
|
|
@@ -3507,6 +3890,167 @@ function buildApi(ctx, workspace, config, options) {
|
|
|
3507
3890
|
usedCast: cast.length,
|
|
3508
3891
|
}
|
|
3509
3892
|
},
|
|
3893
|
+
|
|
3894
|
+
// ── 改成剧本 ────────────────────────────────────────────────
|
|
3895
|
+
// 一章小说 → 一份能配音、能拍的剧本。落在 `books/<书>/scripts/<章号>.md`,
|
|
3896
|
+
// 和章节文件同号,回头一眼能对上「第三章改出来的那份」。
|
|
3897
|
+
|
|
3898
|
+
/** 读这一章改出来的剧本(没改过也正常,返回空串)。 */
|
|
3899
|
+
'novel.script.get': async (body) => {
|
|
3900
|
+
if ((await ensureModules()).novel !== true) return missingFeature('novel')
|
|
3901
|
+
const ws = await root(body)
|
|
3902
|
+
const id = String(body?.id ?? '').trim()
|
|
3903
|
+
if (id === '') return { ok: false, error: '没有说是哪本书' }
|
|
3904
|
+
const target = await scriptTarget(ws, id, body?.index)
|
|
3905
|
+
if (target.error !== undefined) return { ok: false, error: target.error }
|
|
3906
|
+
const got = await novel.readScript(ws, id, target.index)
|
|
3907
|
+
if (got.ok !== true) return got
|
|
3908
|
+
const scan = novel.scanScript(got.text)
|
|
3909
|
+
return { ...got, scan, report: novel.scriptReportText(scan) }
|
|
3910
|
+
},
|
|
3911
|
+
|
|
3912
|
+
/** 存这一章的剧本(手改过的也走这里)。 */
|
|
3913
|
+
'novel.script.save': async (body) => {
|
|
3914
|
+
if ((await ensureModules()).novel !== true) return missingFeature('novel')
|
|
3915
|
+
const ws = await root(body)
|
|
3916
|
+
const id = String(body?.id ?? '').trim()
|
|
3917
|
+
if (id === '') return { ok: false, error: '没有说是哪本书' }
|
|
3918
|
+
const target = await scriptTarget(ws, id, body?.index)
|
|
3919
|
+
if (target.error !== undefined) return { ok: false, error: target.error }
|
|
3920
|
+
const raw = String(body?.text ?? '')
|
|
3921
|
+
// 只剩空格(含全角空格)和换行:这人不小心清空了。
|
|
3922
|
+
// 以前这里直接删文件,回话还说「存好了」——磁盘上那份就再也找不回来。
|
|
3923
|
+
// 现在只回一句「空的,没往里存」,原来的那份一动不动。
|
|
3924
|
+
if (raw.replace(/[\s\u3000]/g, '') === '') {
|
|
3925
|
+
const scan = novel.scanScript('')
|
|
3926
|
+
return { ok: false, blank: true, index: target.index, error: '这一份是空的,没往里存。原来那一份还在。' }
|
|
3927
|
+
}
|
|
3928
|
+
const saved = await novel.writeScript(ws, id, target.index, raw)
|
|
3929
|
+
if (saved.ok !== true) return saved
|
|
3930
|
+
// 扫的是真正落盘的那一份(writeScript 会先剥掉 ``` 围栏)。
|
|
3931
|
+
// 扫原文的话,回执里的场数、字数会和磁盘上那份对不上。
|
|
3932
|
+
const stored = await novel.readScript(ws, id, target.index)
|
|
3933
|
+
const storedText = stored.ok === true ? stored.text : raw
|
|
3934
|
+
const scan = novel.scanScript(storedText)
|
|
3935
|
+
return { ...saved, scan, report: novel.scriptReportText(scan) }
|
|
3936
|
+
},
|
|
3937
|
+
|
|
3938
|
+
/** 这本书改过哪几章。 */
|
|
3939
|
+
'novel.script.list': async (body) => {
|
|
3940
|
+
if ((await ensureModules()).novel !== true) return missingFeature('novel')
|
|
3941
|
+
const ws = await root(body)
|
|
3942
|
+
const id = String(body?.id ?? '').trim()
|
|
3943
|
+
if (id === '') return { ok: false, error: '没有说是哪本书' }
|
|
3944
|
+
const book = await novel.readBook(ws, id)
|
|
3945
|
+
if (book.ok !== true) return { ok: false, error: '这本书不在了。回到书架看一眼,可能被移走了。' }
|
|
3946
|
+
return await novel.listScripts(ws, id)
|
|
3947
|
+
},
|
|
3948
|
+
|
|
3949
|
+
/** 删掉这一章改出来的剧本。章节本身不动。 */
|
|
3950
|
+
'novel.script.delete': async (body) => {
|
|
3951
|
+
if ((await ensureModules()).novel !== true) return missingFeature('novel')
|
|
3952
|
+
const ws = await root(body)
|
|
3953
|
+
const id = String(body?.id ?? '').trim()
|
|
3954
|
+
if (id === '') return { ok: false, error: '没有说是哪本书' }
|
|
3955
|
+
const target = await scriptTarget(ws, id, body?.index)
|
|
3956
|
+
if (target.error !== undefined) return { ok: false, error: target.error }
|
|
3957
|
+
return await novel.deleteScript(ws, id, target.index)
|
|
3958
|
+
},
|
|
3959
|
+
|
|
3960
|
+
/**
|
|
3961
|
+
* 让 AI 把这一章改成剧本。
|
|
3962
|
+
*
|
|
3963
|
+
* 只给这一章的正文 + 人 + 设定 + 上一章剧本的最后一场。
|
|
3964
|
+
* 不给大纲:改剧本不是重写故事,章后面的事它不需要知道——知道了会忍不住
|
|
3965
|
+
* 提前把底抖出来,那是改编里最容易炸的一处。
|
|
3966
|
+
*/
|
|
3967
|
+
'novel.script.draft': async (body) => {
|
|
3968
|
+
if ((await ensureModules()).novel !== true) return missingFeature('novel')
|
|
3969
|
+
const ws = await root(body)
|
|
3970
|
+
const id = String(body?.id ?? '').trim()
|
|
3971
|
+
if (id === '') return { ok: false, error: '没有说是哪本书' }
|
|
3972
|
+
const book = await novel.readBook(ws, id)
|
|
3973
|
+
if (book.ok !== true) return book
|
|
3974
|
+
// 没给章号就用最后一章;给了但不合法要说出来,不能悄悄改成第 1 章去改。
|
|
3975
|
+
const rawIndex = body?.index
|
|
3976
|
+
const gaveIndex = rawIndex !== undefined && rawIndex !== null && String(rawIndex).trim() !== ''
|
|
3977
|
+
if (gaveIndex === true && novel.isValidChapterIndex(rawIndex) !== true) {
|
|
3978
|
+
return { ok: false, error: '章号不对,没法知道你说的是哪一章。' }
|
|
3979
|
+
}
|
|
3980
|
+
const index = gaveIndex === true
|
|
3981
|
+
? Number(String(rawIndex).trim())
|
|
3982
|
+
: (book.chapters.length === 0 ? 1 : book.chapters[book.chapters.length - 1].index)
|
|
3983
|
+
const chapter = await novel.readChapter(ws, id, index)
|
|
3984
|
+
if (chapter.ok !== true) return chapter
|
|
3985
|
+
const chapterBody = String(chapter.body ?? '').trim()
|
|
3986
|
+
if (chapterBody === '') return { ok: false, error: `第 ${index} 章还是空的,没有东西可以改。`, index }
|
|
3987
|
+
if (chapterBody.length > 20000) {
|
|
3988
|
+
return { ok: false, error: '这一章太长(超过两万字),一次改不完。先分成两章再改。', index }
|
|
3989
|
+
}
|
|
3990
|
+
|
|
3991
|
+
// 上一章改出来的剧本,最后一场整段带上:谁站在哪、手上有什么、门开没开。
|
|
3992
|
+
let previousTail = ''
|
|
3993
|
+
if (index > 1) {
|
|
3994
|
+
const prev = await novel.readScript(ws, id, index - 1)
|
|
3995
|
+
if (prev.ok === true && String(prev.text ?? '').trim() !== '') {
|
|
3996
|
+
const parsed = novel.parseScriptScenes(prev.text)
|
|
3997
|
+
const last = parsed.scenes[parsed.scenes.length - 1]
|
|
3998
|
+
previousTail = last === undefined ? novel.tailOf(prev.text, 600) : last.raw.join('\n').trim()
|
|
3999
|
+
}
|
|
4000
|
+
}
|
|
4001
|
+
|
|
4002
|
+
// 世界设定(改剧本时全量给:场的布景、道具、天气都得对得上)
|
|
4003
|
+
const worldNotes = []
|
|
4004
|
+
const worldRel = typeof body?.world === 'string' && body.world.trim() !== '' ? body.world.trim() : ''
|
|
4005
|
+
if (worldRel !== '') {
|
|
4006
|
+
const world = await store.readCard(ws, worldRel)
|
|
4007
|
+
if (world.ok === true) {
|
|
4008
|
+
for (const entry of core.parseWorldEntries(world.sections)) {
|
|
4009
|
+
const content = String(entry?.content ?? '').trim()
|
|
4010
|
+
if (content !== '') worldNotes.push(content)
|
|
4011
|
+
}
|
|
4012
|
+
}
|
|
4013
|
+
}
|
|
4014
|
+
|
|
4015
|
+
const cast = await gatherCast(ws, body?.cast)
|
|
4016
|
+
const firstLine = chapterBody.split(/\r?\n/).find((line) => line.trim() !== '') ?? ''
|
|
4017
|
+
const user = novel.buildScriptPrompt({
|
|
4018
|
+
title: String(book.data?.title ?? id),
|
|
4019
|
+
genre: String(book.data?.genre ?? ''),
|
|
4020
|
+
idea: String(book.idea ?? ''),
|
|
4021
|
+
chapterNo: index,
|
|
4022
|
+
chapterTitle: firstLine.replace(/^#+\s*/, '').trim().slice(0, 60),
|
|
4023
|
+
chapterBody,
|
|
4024
|
+
cast,
|
|
4025
|
+
worldEntries: worldNotes,
|
|
4026
|
+
previousTail,
|
|
4027
|
+
ask: body?.ask,
|
|
4028
|
+
sceneHint: body?.scenes,
|
|
4029
|
+
})
|
|
4030
|
+
const called = await callModel(ctx, {
|
|
4031
|
+
system: novel.buildScriptSystemNote(),
|
|
4032
|
+
user,
|
|
4033
|
+
model: body?.model,
|
|
4034
|
+
})
|
|
4035
|
+
if (called.ok !== true) {
|
|
4036
|
+
return { ok: false, error: `这次没改成:${called.error ?? '过一会儿再试一次'}`, index }
|
|
4037
|
+
}
|
|
4038
|
+
const text = novel.stripFence(called.text)
|
|
4039
|
+
if (text === '') return { ok: false, error: 'AI 这次什么都没给,再点一次试试。', index }
|
|
4040
|
+
|
|
4041
|
+
const scan = novel.scanScript(text)
|
|
4042
|
+
return {
|
|
4043
|
+
ok: true,
|
|
4044
|
+
index,
|
|
4045
|
+
text,
|
|
4046
|
+
scan,
|
|
4047
|
+
report: novel.scriptReportText(scan),
|
|
4048
|
+
// 不落盘:改出来的东西人要先看、能删掉半场、能整段重写。存盘由 script.save 做。
|
|
4049
|
+
usedCast: cast.length,
|
|
4050
|
+
usedWorld: worldNotes.length,
|
|
4051
|
+
continued: previousTail !== '',
|
|
4052
|
+
}
|
|
4053
|
+
},
|
|
3510
4054
|
}
|
|
3511
4055
|
}
|
|
3512
4056
|
|
|
@@ -3517,6 +4061,31 @@ function buildApi(ctx, workspace, config, options) {
|
|
|
3517
4061
|
* 它才不会把「说话很冲的那个人」写成温和的——那是长篇最容易崩的地方。
|
|
3518
4062
|
* 每张卡只取前 500 字:卡可能写得很长,全贴会把大纲和上一章挤掉。
|
|
3519
4063
|
*/
|
|
4064
|
+
/**
|
|
4065
|
+
* 章号闸。
|
|
4066
|
+
*
|
|
4067
|
+
* `chapterFileName` 里有 `Math.max(1, Math.min(999, Math.floor(Number(index) || 1)))`
|
|
4068
|
+
* —— 它把 0、-1、'abc'、null 一律**悄悄**夹成 1。对「读」来说没问题,
|
|
4069
|
+
* 对「写」就是灾难:`novel.script.save({index:0})` 会盖掉第 1 章原来那份剧本,
|
|
4070
|
+
* 而且回话说的是「存好了」。
|
|
4071
|
+
*
|
|
4072
|
+
* 所以写之前先在这里拦一道:章号得是正整数,而且这一章得真的存在。
|
|
4073
|
+
* 返回 `{ index }` 或者 `{ error }`。
|
|
4074
|
+
*/
|
|
4075
|
+
async function scriptTarget(ws, id, rawIndex) {
|
|
4076
|
+
if (novel.isValidChapterIndex(rawIndex) !== true) {
|
|
4077
|
+
return { error: '章号不对,没法知道你说的是哪一章。' }
|
|
4078
|
+
}
|
|
4079
|
+
const index = Number(String(rawIndex).trim())
|
|
4080
|
+
const book = await novel.readBook(ws, id)
|
|
4081
|
+
if (book.ok !== true) return { error: '这本书不在了。回到书架看一眼,可能被移走了。' }
|
|
4082
|
+
const exists = Array.isArray(book.chapters) && book.chapters.some((c) => Number(c.index) === index)
|
|
4083
|
+
if (!exists) {
|
|
4084
|
+
return { error: `这本书没有第 ${index} 章。先翻到真正的那一章再存。` }
|
|
4085
|
+
}
|
|
4086
|
+
return { index }
|
|
4087
|
+
}
|
|
4088
|
+
|
|
3520
4089
|
async function gatherCast(ws, wants) {
|
|
3521
4090
|
const out = []
|
|
3522
4091
|
const list = Array.isArray(wants) ? wants.slice(0, 8) : []
|
|
@@ -3853,11 +4422,11 @@ function cardPathSync(root, id) {
|
|
|
3853
4422
|
async function clearPinsFor(ws, rel, data) {
|
|
3854
4423
|
const state = await store.readConfigState(ws)
|
|
3855
4424
|
if (state.ok !== true) return
|
|
3856
|
-
const pins = { real: '', tavern: '', novel: '', ...(state.config?.default_cards ?? {}) }
|
|
4425
|
+
const pins = { real: '', tavern: '', novel: '', diary: '', ...(state.config?.default_cards ?? {}) }
|
|
3857
4426
|
const id = String(data?.id ?? '')
|
|
3858
4427
|
const stem = path.posix.basename(rel).replace(/\.card\.md$/i, '')
|
|
3859
4428
|
let changed = false
|
|
3860
|
-
for (const mode of ['real', 'tavern', 'novel']) {
|
|
4429
|
+
for (const mode of ['real', 'tavern', 'novel', 'diary']) {
|
|
3861
4430
|
const picked = String(pins[mode] ?? '')
|
|
3862
4431
|
if (picked !== '' && (picked === id || picked === rel || picked === stem)) {
|
|
3863
4432
|
pins[mode] = ''
|
|
@@ -3880,6 +4449,46 @@ function pinnedCardIdSync(root, mode) {
|
|
|
3880
4449
|
}
|
|
3881
4450
|
}
|
|
3882
4451
|
|
|
4452
|
+
/**
|
|
4453
|
+
* 日记放在哪个文件夹。
|
|
4454
|
+
*
|
|
4455
|
+
* 和别的东西不一样:日记**不在这个工作区里**,它是用户在第一次点「写日记」时
|
|
4456
|
+
* 自己挑的一个位置。所以这里不回落到工作区,没定过就老实说没定。
|
|
4457
|
+
*/
|
|
4458
|
+
/**
|
|
4459
|
+
* 日记文件夹不能挑在这些地方。
|
|
4460
|
+
*
|
|
4461
|
+
* 以前只挡了文件系统根目录,于是 `~/.ssh`、`~/Library`、`/tmp` 全照收:
|
|
4462
|
+
* 一个手滑把 `.ssh` 设成日记夹,往后每一次「写日记」都往密钥目录里写文件。
|
|
4463
|
+
* 这里只挡「明显不该往里写东西」的几处,不是白名单——用户自己的
|
|
4464
|
+
* `~/Documents/xxx`、外接盘、iCloud 都照旧能选。
|
|
4465
|
+
*
|
|
4466
|
+
* @returns {string} 不许的话,一句人话;可以的话空串。
|
|
4467
|
+
*/
|
|
4468
|
+
function diaryDirVeto(dir) {
|
|
4469
|
+
const abs = path.normalize(String(dir ?? ''))
|
|
4470
|
+
const home = homedir()
|
|
4471
|
+
const under = (base) => base !== '' && (abs === base || abs.startsWith(base + path.sep))
|
|
4472
|
+
if (abs === path.parse(abs).root) return '不能整个磁盘根目录都当日记文件夹。换一个位置。'
|
|
4473
|
+
if (abs === os.tmpdir()) {
|
|
4474
|
+
// 只挡临时目录本身:那是系统会整个清掉的地方。它下面自己建的具体文件夹
|
|
4475
|
+
// 不挡——外接盘、同步盘的挂载点有时候就长在系统临时路径下面。
|
|
4476
|
+
return '别把系统临时文件夹本身当日记文件夹——那里会被系统整个清掉,日记会跟着没。换一个位置。'
|
|
4477
|
+
}
|
|
4478
|
+
if (under(path.join(home, '.ssh'))) return '这是放密钥的地方,不能当日记文件夹。换一个位置。'
|
|
4479
|
+
if (under(path.join(home, '.gnupg'))) return '这是放密钥的地方,不能当日记文件夹。换一个位置。'
|
|
4480
|
+
if (under(path.join(home, 'Library'))) return '这是系统自己用的文件夹,别往里写日记。换一个位置,比如「文稿」。'
|
|
4481
|
+
if (abs === home) return '整个家目录太大了,给日记单独建个文件夹吧。换一个位置。'
|
|
4482
|
+
return ''
|
|
4483
|
+
}
|
|
4484
|
+
|
|
4485
|
+
async function diaryDirOf(ws) {
|
|
4486
|
+
const state = await store.readConfigState(ws)
|
|
4487
|
+
if (state.ok !== true) return { ok: false, error: state.error ?? '这个文件夹里的设置读不出来。' }
|
|
4488
|
+
const dir = diary.diaryRootFrom(state.config ?? {})
|
|
4489
|
+
return { ok: true, dir }
|
|
4490
|
+
}
|
|
4491
|
+
|
|
3883
4492
|
/** 把世界书条目排成人能读、模型也好读的样子。 */
|
|
3884
4493
|
function worldEntriesText(entries) {
|
|
3885
4494
|
const list = Array.isArray(entries) ? entries : []
|
|
@@ -4030,6 +4639,7 @@ function modeFromPresetRegistry(ctx, agent) {
|
|
|
4030
4639
|
const blob = JSON.stringify(rows)
|
|
4031
4640
|
if (blob.includes('lc-tavern')) return 'tavern'
|
|
4032
4641
|
if (blob.includes('lc-novel')) return 'novel'
|
|
4642
|
+
if (blob.includes('lc-diary')) return 'diary'
|
|
4033
4643
|
} catch {
|
|
4034
4644
|
/* 问不到就当不知道 */
|
|
4035
4645
|
}
|
|
@@ -4042,6 +4652,7 @@ function modeForAgent(agent) {
|
|
|
4042
4652
|
if (preset === '') return ''
|
|
4043
4653
|
if (preset.includes('lc-tavern')) return 'tavern'
|
|
4044
4654
|
if (preset.includes('lc-novel')) return 'novel'
|
|
4655
|
+
if (preset.includes('lc-diary')) return 'diary'
|
|
4045
4656
|
return ''
|
|
4046
4657
|
}
|
|
4047
4658
|
|
|
@@ -4138,6 +4749,22 @@ function registerInterviewSkill(ctx) {
|
|
|
4138
4749
|
fallback: '中文小说与长文的写法:先分清用不用人物卡,按传统文学的标准写正文,要连载节奏就切。',
|
|
4139
4750
|
label: '写作',
|
|
4140
4751
|
})
|
|
4752
|
+
// 小说改剧本。「改剧本」按钮背后的提示词在 lib/novel.js 里,这份 skill 是给
|
|
4753
|
+
// 用户在对话里直接说「把这一章改成剧本」用的——两条路走的是同一套规矩。
|
|
4754
|
+
registerBundledSkill(ctx, {
|
|
4755
|
+
dir: 'novel-to-script',
|
|
4756
|
+
name: 'novel-to-script',
|
|
4757
|
+
fallback: '小说改剧本:分场、把叙述换成 △ 动作、把心理换成演得出来的东西、台词按标点分工。',
|
|
4758
|
+
label: '改剧本',
|
|
4759
|
+
})
|
|
4760
|
+
// 带写日记的那份手艺。它不只是「怎么问」,还写着写完之后怎么反哺
|
|
4761
|
+
// 「我」那张卡和日记助手那张卡——两条路都在这一份里。
|
|
4762
|
+
registerBundledSkill(ctx, {
|
|
4763
|
+
dir: 'lifecard-diary',
|
|
4764
|
+
name: 'lifecard-diary',
|
|
4765
|
+
fallback: '带写今天这一篇日记:一件事、情绪三层、一个能做的决定,末尾四样各打个分。',
|
|
4766
|
+
label: '日记',
|
|
4767
|
+
})
|
|
4141
4768
|
// 这三份是写作用得上的通用手艺,随包一起发:装插件即等于有,
|
|
4142
4769
|
// 换台机器不必再单独装一遍。名字与内容都保持原样,方便用户照旧用
|
|
4143
4770
|
// `/human-writing`、`/blind-review-loop`、`/visual-novel` 唤起。
|
|
@@ -4385,14 +5012,21 @@ export function apply(ctx, config) {
|
|
|
4385
5012
|
// 没有 Origin 就是同源请求(浏览器对同源 POST 一般不送);`null` 是
|
|
4386
5013
|
// 沙箱里的 iframe。这两种放行,只有「明确来自别家站点」才拦。
|
|
4387
5014
|
if (origin !== '' && origin !== 'null') {
|
|
4388
|
-
|
|
5015
|
+
// 只比「Origin 和 Host 一致」是不够的:DNS rebinding 下攻击者页面的
|
|
5016
|
+
// Origin 和它请求的 Host 都是它自己的域名,两面一致照样放行,
|
|
5017
|
+
// 于是别人的网页能读、能改你的日记。这里再加一条——这一台服务只在
|
|
5018
|
+
// 本机跑,所以请求的主机名必须真的是回环地址,别的一律不收。
|
|
5019
|
+
let allowed = false
|
|
4389
5020
|
try {
|
|
4390
5021
|
const host = String(req.headers?.host ?? '')
|
|
4391
|
-
|
|
5022
|
+
const originUrl = new URL(origin)
|
|
5023
|
+
const hostName = host === '' ? '' : new URL(`http://${host}`).hostname
|
|
5024
|
+
const loopback = hostName === '127.0.0.1' || hostName === 'localhost' || hostName === '::1' || hostName === '[::1]'
|
|
5025
|
+
allowed = loopback && originUrl.host === host
|
|
4392
5026
|
} catch {
|
|
4393
|
-
|
|
5027
|
+
allowed = false
|
|
4394
5028
|
}
|
|
4395
|
-
if (!
|
|
5029
|
+
if (!allowed) {
|
|
4396
5030
|
writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: '这个来源不能改档案' } })
|
|
4397
5031
|
return
|
|
4398
5032
|
}
|