feiyu-brain 1.4.2 → 1.5.1
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 +160 -5
- package/adapters/qq-bridge.js +169 -26
- package/cli.mjs +276 -3
- package/cordis.patch.yml +32 -2
- package/core/body.js +13 -1
- package/core/bond.js +186 -0
- package/core/concept.js +138 -0
- package/core/diary.js +119 -0
- package/core/extract.js +124 -12
- package/core/memory.js +539 -18
- package/core/migrate.js +170 -0
- package/core/persona.js +91 -4
- package/core/relation.js +78 -0
- package/core/self.js +72 -0
- package/docs/ADAPTER-CONTRACT.md +101 -0
- package/docs/CHANGELOG-1.5.md +136 -0
- package/docs/MEMORY.md +454 -0
- package/docs/TROUBLESHOOT.md +136 -0
- package/index.js +1294 -56
- package/lib/doctor.mjs +181 -0
- package/lib/dsh-plugin.mjs +197 -15
- package/lib/serve.mjs +187 -0
- package/market/fangqiuci__feiyu-brain.yml +2 -2
- package/package.json +3 -2
- package/selftest.mjs +37 -3
- package/store.js +172 -13
package/core/concept.js
ADDED
|
@@ -0,0 +1,138 @@
|
|
|
1
|
+
// 概念:什么是什么,以及为什么要这么做。
|
|
2
|
+
//
|
|
3
|
+
// 前面所有的层都在记"发生了":
|
|
4
|
+
// 细节 → 卡片 → 纲 → 伞
|
|
5
|
+
//
|
|
6
|
+
// 但一条鱼可以有四十条"该上学了"的经历,仍然不知道"上学"是什么。
|
|
7
|
+
// 那不是记忆,那是噪音。
|
|
8
|
+
//
|
|
9
|
+
// 概念层干的事只有一件:**给旧经历贴上意义。**
|
|
10
|
+
//
|
|
11
|
+
// 别人解释之前: 经历 40 条,全叫「该上学了」,不知道是啥
|
|
12
|
+
// 别人解释之后: 「上学:为了学到知识、学会道理」
|
|
13
|
+
// → 那 40 条经历瞬间有了名字,也才有了感情可言
|
|
14
|
+
//
|
|
15
|
+
// 关键原则(跟情绪词一样):
|
|
16
|
+
// **不知道就是不知道。** 没有定义就说"我知道这个词,但不知道它什么意思"。
|
|
17
|
+
// 不许编——编出来的理解比没有理解更糟。
|
|
18
|
+
|
|
19
|
+
import { plainText } from './extract.js';
|
|
20
|
+
|
|
21
|
+
/** 概念最短几个字 */
|
|
22
|
+
const MIN_TERM = 2;
|
|
23
|
+
|
|
24
|
+
function norm(term) {
|
|
25
|
+
return plainText(String(term ?? '')).replace(/[「」“”"'!?!?,,。.]/g, '').trim();
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
/**
|
|
29
|
+
* 学会一个概念。**必须有人告诉她**(用户、模型、或她问来的)。
|
|
30
|
+
*
|
|
31
|
+
* @param {object} memory
|
|
32
|
+
* @param {string} term
|
|
33
|
+
* @param {object} o
|
|
34
|
+
* @param {string} o.definition 是什么("为了学到知识、学会道理")
|
|
35
|
+
* @param {string} [o.why] 为什么要这么做
|
|
36
|
+
* @param {'told'|'asked'|'read'} [o.source]
|
|
37
|
+
* @param {number} [o.at]
|
|
38
|
+
*/
|
|
39
|
+
export function learnConcept(memory, term, { definition = '', why = '', source = 'told', at = Date.now(), who = '' } = {}) {
|
|
40
|
+
const t = norm(term);
|
|
41
|
+
if (t.length < MIN_TERM) return { ok: false, reason: '概念太短' };
|
|
42
|
+
const def = plainText(String(definition ?? '').trim());
|
|
43
|
+
if (!def) return { ok: false, reason: '没有解释就不算学会' };
|
|
44
|
+
|
|
45
|
+
if (!memory.concepts) memory.concepts = {};
|
|
46
|
+
const prev = memory.concepts[t];
|
|
47
|
+
memory.concepts[t] = {
|
|
48
|
+
term: t,
|
|
49
|
+
definition: def.slice(0, 160),
|
|
50
|
+
why: plainText(String(why ?? '').trim()).slice(0, 160),
|
|
51
|
+
source,
|
|
52
|
+
who,
|
|
53
|
+
at,
|
|
54
|
+
firstAt: prev?.firstAt ?? at,
|
|
55
|
+
learnCount: (prev?.learnCount ?? 0) + 1,
|
|
56
|
+
};
|
|
57
|
+
|
|
58
|
+
// 给旧经历贴标签:这才是"想通了"
|
|
59
|
+
const linked = linkConceptEpisodes(memory, t);
|
|
60
|
+
return { ok: true, term: t, concept: memory.concepts[t], linked };
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
/**
|
|
64
|
+
* 把已有的经历跟她刚学会的概念挂上。
|
|
65
|
+
*
|
|
66
|
+
* 这一步才是关键:不是新增记忆,是**让过去四十件事突然有了名字**。
|
|
67
|
+
*/
|
|
68
|
+
export function linkConceptEpisodes(memory, term) {
|
|
69
|
+
const t = norm(term);
|
|
70
|
+
if (!t) return 0;
|
|
71
|
+
let n = 0;
|
|
72
|
+
const tag = (e) => {
|
|
73
|
+
if (!e || !String(e.what ?? '').includes(t)) return false;
|
|
74
|
+
e.concept = t;
|
|
75
|
+
// 有意义的经历不该被压成无意义的"记不清了"
|
|
76
|
+
e.meaningful = true;
|
|
77
|
+
n += 1;
|
|
78
|
+
return true;
|
|
79
|
+
};
|
|
80
|
+
for (const e of memory.episodes ?? []) tag(e);
|
|
81
|
+
for (const c of memory.cards ?? []) tag(c);
|
|
82
|
+
return n;
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
export function conceptOf(memory, term) {
|
|
86
|
+
return memory?.concepts?.[norm(term)] ?? null;
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
/**
|
|
90
|
+
* 问她"X 是什么"。
|
|
91
|
+
* 有定义就说定义;没定义就老实说不知道——**不编**。
|
|
92
|
+
*/
|
|
93
|
+
export function conceptAnswer(memory, term) {
|
|
94
|
+
const t = norm(term);
|
|
95
|
+
const c = conceptOf(memory, t);
|
|
96
|
+
if (!c) {
|
|
97
|
+
const related = (memory.episodes ?? []).filter((e) => String(e.what ?? '').includes(t)).length;
|
|
98
|
+
return {
|
|
99
|
+
known: false,
|
|
100
|
+
term: t,
|
|
101
|
+
text: related
|
|
102
|
+
? `我知道「${t}」这个词,我好像经历过 ${related} 次,但我不知道它是什么意思。`
|
|
103
|
+
: `我不知道「${t}」是什么。`,
|
|
104
|
+
related,
|
|
105
|
+
};
|
|
106
|
+
}
|
|
107
|
+
const why = c.why ? `(${c.why})` : '';
|
|
108
|
+
return { known: true, term: t, text: `${t}:${c.definition}${why}`, concept: c };
|
|
109
|
+
}
|
|
110
|
+
|
|
111
|
+
/** 在一段话里找出她已知的概念 */
|
|
112
|
+
export function conceptsIn(memory, text) {
|
|
113
|
+
const s = String(text ?? '');
|
|
114
|
+
const out = [];
|
|
115
|
+
for (const [term, c] of Object.entries(memory?.concepts ?? {})) {
|
|
116
|
+
if (term && s.includes(term)) out.push(c);
|
|
117
|
+
}
|
|
118
|
+
return out.slice(0, 3);
|
|
119
|
+
}
|
|
120
|
+
|
|
121
|
+
/**
|
|
122
|
+
* 她主动问问题:遇到不懂的东西,会去问。
|
|
123
|
+
*
|
|
124
|
+
* 这不是"知识库查询"——是**动机**:
|
|
125
|
+
* 我向别人请教,是因为我不会、我不知道。
|
|
126
|
+
*/
|
|
127
|
+
export function makeQuestion(memory, term, { knower = '' } = {}) {
|
|
128
|
+
const t = norm(term);
|
|
129
|
+
const ans = conceptAnswer(memory, t);
|
|
130
|
+
return {
|
|
131
|
+
term: t,
|
|
132
|
+
known: ans.known,
|
|
133
|
+
asked: ans.known ? null : { to: knower, text: `${t}是什么?`, at: Date.now() },
|
|
134
|
+
text: ans.known
|
|
135
|
+
? `这个我知道:${ans.text}`
|
|
136
|
+
: (knower ? `${knower},${t}是什么?` : `${t}是什么?`),
|
|
137
|
+
};
|
|
138
|
+
}
|
package/core/diary.js
ADDED
|
@@ -0,0 +1,119 @@
|
|
|
1
|
+
// 日记 = 她自己的心房。
|
|
2
|
+
//
|
|
3
|
+
// 不是宿主的流水账,是她用自己口吻写下来的东西。
|
|
4
|
+
// 脑子不生成文笔(那是嘴的事),脑子负责三件事:
|
|
5
|
+
// ① 把今天发生了什么整理成素材(dayDigest)
|
|
6
|
+
// ② 给一个第一人称的骨架,**带上当时的心情**
|
|
7
|
+
// ③ 写好的存回去,将来能被检索到(writeDiary / readDiary)
|
|
8
|
+
//
|
|
9
|
+
// 心情从哪来:每条经历在 observe 时就记下了 mood(当时她什么感觉)。
|
|
10
|
+
// 搬进来的老记忆没有 mood —— 那就老实写"那天没记",不编。
|
|
11
|
+
|
|
12
|
+
const DAY_MS = 24 * 60 * 60 * 1000;
|
|
13
|
+
const MEANINGLESS = new Set(['', '平静', '说不上来']);
|
|
14
|
+
|
|
15
|
+
export function dayKey(at = Date.now()) {
|
|
16
|
+
const d = new Date(at);
|
|
17
|
+
const p = (n) => String(n).padStart(2, '0');
|
|
18
|
+
return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
|
|
19
|
+
}
|
|
20
|
+
|
|
21
|
+
function dayRange(dateStr) {
|
|
22
|
+
const [y, m, d] = String(dateStr).split('-').map(Number);
|
|
23
|
+
const start = new Date(y, (m ?? 1) - 1, d ?? 1, 0, 0, 0, 0).getTime();
|
|
24
|
+
return { start, end: start + DAY_MS };
|
|
25
|
+
}
|
|
26
|
+
|
|
27
|
+
function meaningful(mood) {
|
|
28
|
+
return typeof mood === 'string' && !MEANINGLESS.has(mood.trim());
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
/** 这一天她经历了什么(按时间升序) */
|
|
32
|
+
export function episodesOfDay(memory, dateStr) {
|
|
33
|
+
const { start, end } = dayRange(dateStr);
|
|
34
|
+
return (memory.episodes ?? [])
|
|
35
|
+
.filter((e) => (e.at ?? 0) >= start && (e.at ?? 0) < end)
|
|
36
|
+
.sort((a, b) => (a.at ?? 0) - (b.at ?? 0));
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
/** 当天出现过的情绪,按次数排,最多三个 */
|
|
40
|
+
export function moodsOfDay(memory, dateStr) {
|
|
41
|
+
const eps = episodesOfDay(memory, dateStr);
|
|
42
|
+
const freq = new Map();
|
|
43
|
+
for (const e of eps) {
|
|
44
|
+
const m = String(e.mood ?? '').trim();
|
|
45
|
+
if (!meaningful(m)) continue;
|
|
46
|
+
freq.set(m, (freq.get(m) ?? 0) + 1);
|
|
47
|
+
}
|
|
48
|
+
return [...freq.entries()].sort((a, b) => b[1] - a[1]).map(([mood, n]) => ({ mood, count: n }));
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
/**
|
|
52
|
+
* 今天的素材:发生了啥、见了谁、看了什么、**当时什么心情**。
|
|
53
|
+
* 宿主拿这段去让模型用她的口吻写成日记,再调 writeDiary 存回来。
|
|
54
|
+
*/
|
|
55
|
+
export function dayDigest(brain, dateStr = dayKey()) {
|
|
56
|
+
const eps = episodesOfDay(brain.memory, dateStr);
|
|
57
|
+
const people = [...new Set(eps.map((e) => e.who).filter(Boolean))];
|
|
58
|
+
|
|
59
|
+
// 那天刷过什么
|
|
60
|
+
const { start, end } = dayRange(dateStr);
|
|
61
|
+
const apps = {};
|
|
62
|
+
for (const [app, bucket] of Object.entries(brain.memory?.apps ?? {})) {
|
|
63
|
+
const items = (bucket.seen ?? []).filter((s) => (s.at ?? 0) >= start && (s.at ?? 0) < end);
|
|
64
|
+
if (items.length) {
|
|
65
|
+
apps[app] = {
|
|
66
|
+
count: items.length,
|
|
67
|
+
titles: items.slice(-3).map((i) => i.title),
|
|
68
|
+
kinds: [...new Set(items.map((i) => i.kind).filter(Boolean))],
|
|
69
|
+
};
|
|
70
|
+
}
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
const moods = moodsOfDay(brain.memory, dateStr);
|
|
74
|
+
// 当天没有经历情绪时,才退回"现在的心情"(只对今天成立)
|
|
75
|
+
const nowMood = brain.affect?.mood ?? '';
|
|
76
|
+
const isToday = dateStr === dayKey();
|
|
77
|
+
const moodLine = moods.length
|
|
78
|
+
? moods.map((m) => m.mood).slice(0, 3).join(' / ')
|
|
79
|
+
: (isToday && meaningful(nowMood) ? nowMood : '');
|
|
80
|
+
|
|
81
|
+
const lines = [];
|
|
82
|
+
lines.push(`# ${dateStr}`);
|
|
83
|
+
lines.push('');
|
|
84
|
+
if (people.length) lines.push(`今天跟${people.slice(0, 4).join('、')}说了话。`);
|
|
85
|
+
if (eps.length) {
|
|
86
|
+
lines.push('');
|
|
87
|
+
for (const e of eps.slice(-12)) {
|
|
88
|
+
const who = e.who ? `${e.who}:` : '';
|
|
89
|
+
const feel = meaningful(e.mood) ? `(当时${e.mood})` : '';
|
|
90
|
+
lines.push(`- ${who}「${String(e.what ?? '').slice(0, 60)}」${feel}`);
|
|
91
|
+
}
|
|
92
|
+
}
|
|
93
|
+
const appNames = Object.keys(apps);
|
|
94
|
+
if (appNames.length) {
|
|
95
|
+
lines.push('');
|
|
96
|
+
for (const app of appNames) {
|
|
97
|
+
const a = apps[app];
|
|
98
|
+
lines.push(`在${app}上待了会儿,看了${a.count}条${a.kinds.length ? `(${a.kinds.join('/')})` : ''}。`);
|
|
99
|
+
}
|
|
100
|
+
}
|
|
101
|
+
lines.push('');
|
|
102
|
+
lines.push(`心情:${moodLine || '(那天没记)'}`);
|
|
103
|
+
lines.push('');
|
|
104
|
+
|
|
105
|
+
return {
|
|
106
|
+
date: dateStr,
|
|
107
|
+
episodes: eps.length,
|
|
108
|
+
people,
|
|
109
|
+
apps,
|
|
110
|
+
mood: moodLine,
|
|
111
|
+
moods,
|
|
112
|
+
/** 那天有记录的条数,用来区分"真的平静"和"没记" */
|
|
113
|
+
moodRecorded: moods.length > 0,
|
|
114
|
+
/** 第一人称骨架 —— 她自己往下写,别照抄 */
|
|
115
|
+
draft: lines.join('\n'),
|
|
116
|
+
/** 给模型的一句话提示 */
|
|
117
|
+
hint: '用她自己的口吻把今天写成日记,别用第三人称,别总结升华;有心情就写进去,那天没记就别编。',
|
|
118
|
+
};
|
|
119
|
+
}
|
package/core/extract.js
CHANGED
|
@@ -45,7 +45,8 @@ function countKeyword(text, words) {
|
|
|
45
45
|
}
|
|
46
46
|
|
|
47
47
|
/**
|
|
48
|
-
* 从人设卡正文抽出 traits(0~1
|
|
48
|
+
* 从人设卡正文抽出 traits(0~1)——**已知的 12 个维度**。
|
|
49
|
+
* 这是"常见结果"的先验词表,不是封闭枚举;新维度由 extractOpenTraits 自己长。
|
|
49
50
|
*/
|
|
50
51
|
export function extractTraits(cardText) {
|
|
51
52
|
const raw = {};
|
|
@@ -61,6 +62,74 @@ export function extractTraits(cardText) {
|
|
|
61
62
|
return traits;
|
|
62
63
|
}
|
|
63
64
|
|
|
65
|
+
/* ── 开放维度:她自己长出来的性格 ─────────────────────────────
|
|
66
|
+
*
|
|
67
|
+
* 12 个已知维度只是"常见说法"的词表,不是唯一答案。
|
|
68
|
+
* 卡里写"我这人特别较真""我有点社恐",「较真」「社恐」不是词表里的,
|
|
69
|
+
* 但它们确实描述她——那就该成为维度。
|
|
70
|
+
*
|
|
71
|
+
* 抽取规则(确定性,不靠模型):
|
|
72
|
+
* ① 「很/有点/特别/太/超/挺/比较 + X」里的 X
|
|
73
|
+
* ② 行首「我 + X,」里的 X
|
|
74
|
+
* ③ 命中已知词表的归到已知维度,其余作为新维度
|
|
75
|
+
*/
|
|
76
|
+
|
|
77
|
+
const ADVERB_RE = /(?:很|有点|特别|太|超|挺|比较|蛮|相当)([\u4e00-\u9fa5]{2,3})/g;
|
|
78
|
+
const SELF_RE = /我(?:这人|这个人|嘛|呢)?([\u4e00-\u9fa5]{2,3})(?=[,,。;;]|\s|$)/g;
|
|
79
|
+
|
|
80
|
+
/** 这些不是性格,是动作/虚词 */
|
|
81
|
+
const NOT_TRAIT = new Set([
|
|
82
|
+
'觉得', '认为', '知道', '喜欢', '讨厌', '想要', '需要', '可以', '应该', '不会', '不要',
|
|
83
|
+
'就是', '还是', '也是', '不是', '有点', '一些', '什么', '这个', '那个', '一个', '时候',
|
|
84
|
+
'说话', '做事', '这样', '那样', '一样', '很多', '多少', '怎么', '为什么',
|
|
85
|
+
]);
|
|
86
|
+
|
|
87
|
+
/** 已被已知词表覆盖的说法,不再重复建维度 */
|
|
88
|
+
function knownTraitOf(word) {
|
|
89
|
+
for (const [trait, words] of Object.entries(TRAIT_LEXICON)) {
|
|
90
|
+
if (trait === word) return trait;
|
|
91
|
+
if (words.some((w) => w === word || w.includes(word) || word.includes(w))) return trait;
|
|
92
|
+
}
|
|
93
|
+
return null;
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
/**
|
|
97
|
+
* 抽出「开放维度」——卡里出现、但不在 12 维词表里的性格词。
|
|
98
|
+
* @returns {Record<string, number>} 新维度 → 权重
|
|
99
|
+
*/
|
|
100
|
+
const ADVERBS = ['比较', '相当', '特别', '有点', '很', '太', '超', '挺', '蛮'];
|
|
101
|
+
|
|
102
|
+
function stripAdverb(word) {
|
|
103
|
+
for (const a of ADVERBS) {
|
|
104
|
+
if (word.startsWith(a) && word.length > a.length + 1) return word.slice(a.length);
|
|
105
|
+
}
|
|
106
|
+
return word;
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
export function extractOpenTraits(cardText, { max = 8, known = null } = {}) {
|
|
110
|
+
const text = plainText(cardText);
|
|
111
|
+
const counts = new Map();
|
|
112
|
+
|
|
113
|
+
const add = (raw) => {
|
|
114
|
+
const word = stripAdverb(String(raw ?? '').trim());
|
|
115
|
+
if (!word || word.length < 2 || word.length > 4) return;
|
|
116
|
+
if (NOT_TRAIT.has(word)) return;
|
|
117
|
+
if (knownTraitOf(word)) return; // 归到已知维度了,不重复
|
|
118
|
+
if (known && known[word] !== undefined) return;
|
|
119
|
+
counts.set(word, (counts.get(word) ?? 0) + 1);
|
|
120
|
+
};
|
|
121
|
+
|
|
122
|
+
for (const m of text.matchAll(ADVERB_RE)) add(m[1]);
|
|
123
|
+
for (const m of text.matchAll(SELF_RE)) add(m[1]);
|
|
124
|
+
|
|
125
|
+
const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, max);
|
|
126
|
+
const maxN = Math.max(1, ...sorted.map(([, n]) => n));
|
|
127
|
+
const out = {};
|
|
128
|
+
for (const [word, n] of sorted) {
|
|
129
|
+
out[word] = Math.max(0.3, Math.min(1, Math.pow(n / maxN, TRAIT_CURVE)));
|
|
130
|
+
}
|
|
131
|
+
return out;
|
|
132
|
+
}
|
|
64
133
|
/**
|
|
65
134
|
* 手写覆盖:卡里写一行 `性格:嘴硬=0.9 心软=0.6`,就按这个来。
|
|
66
135
|
* 用来治"自动统计抽不准"——人比算法更知道她是啥样。
|
|
@@ -108,20 +177,24 @@ export function plainText(t) {
|
|
|
108
177
|
* preference 0.70
|
|
109
178
|
* 其余 0.60 → 靠经历慢慢涨落
|
|
110
179
|
*/
|
|
111
|
-
export function extractUnits(cardText, { max = 200 } = {}) {
|
|
180
|
+
export function extractUnits(cardText, { max = 200, log = null } = {}) {
|
|
112
181
|
const lines = cardText.split(/\r?\n/);
|
|
113
182
|
const units = [];
|
|
114
183
|
let section = '';
|
|
115
184
|
let sectionSkipped = false;
|
|
116
185
|
|
|
186
|
+
const drop = (raw, reason) => {
|
|
187
|
+
if (log) log({ kept: false, reason, section, text: plainText(raw) });
|
|
188
|
+
};
|
|
189
|
+
|
|
117
190
|
const push = (raw, kind, weight) => {
|
|
118
191
|
const t = plainText(raw);
|
|
119
|
-
if (t.length < 5 || t.length > 140) return;
|
|
120
|
-
if (/^(例如|比如|例子)/.test(t)) return;
|
|
121
|
-
if (META_RE.test(t)) return;
|
|
192
|
+
if (t.length < 5 || t.length > 140) { drop(raw, 'too-short-or-long'); return; }
|
|
193
|
+
if (/^(例如|比如|例子)/.test(t)) { drop(raw, 'example'); return; }
|
|
194
|
+
if (META_RE.test(t)) { drop(raw, 'meta'); return; }
|
|
122
195
|
// `性格:嘴硬=0.9` 是给解析器的指令,不是她的一条人格
|
|
123
|
-
if (/^(?:性格|特质|traits)\s*[::]/i.test(t)) return;
|
|
124
|
-
if (units.length >= max) return;
|
|
196
|
+
if (/^(?:性格|特质|traits)\s*[::]/i.test(t)) { drop(raw, 'trait-hint'); return; }
|
|
197
|
+
if (units.length >= max) { drop(raw, 'over-max'); return; }
|
|
125
198
|
units.push({
|
|
126
199
|
id: `u${String(units.length + 1).padStart(3, '0')}`,
|
|
127
200
|
text: t,
|
|
@@ -131,6 +204,7 @@ export function extractUnits(cardText, { max = 200 } = {}) {
|
|
|
131
204
|
lastTouched: 0,
|
|
132
205
|
section,
|
|
133
206
|
});
|
|
207
|
+
if (log) log({ kept: true, kind, weight, section, text: t });
|
|
134
208
|
};
|
|
135
209
|
|
|
136
210
|
for (const rawLine of lines) {
|
|
@@ -138,15 +212,16 @@ export function extractUnits(cardText, { max = 200 } = {}) {
|
|
|
138
212
|
const line = rawLine.trim();
|
|
139
213
|
if (!line) continue;
|
|
140
214
|
// 缩进的子项是"例子",不是"命题"(梗列表、示范句都在这一层)
|
|
141
|
-
if (indent >= 2) continue;
|
|
215
|
+
if (indent >= 2) { drop(line, 'indented'); continue; }
|
|
142
216
|
|
|
143
217
|
const heading = /^##\s+(.+)$/.exec(line);
|
|
144
218
|
if (heading) {
|
|
145
219
|
section = plainText(heading[1]);
|
|
146
220
|
sectionSkipped = SKIP_SECTIONS.some((re) => re.test(section));
|
|
221
|
+
if (log) log({ kept: false, reason: 'heading', section, text: section });
|
|
147
222
|
continue;
|
|
148
223
|
}
|
|
149
|
-
if (sectionSkipped) continue;
|
|
224
|
+
if (sectionSkipped) { drop(line, 'skipped-section'); continue; }
|
|
150
225
|
|
|
151
226
|
let text = null;
|
|
152
227
|
const bullet = /^[-*]\s+(.+)$/.exec(line);
|
|
@@ -159,11 +234,12 @@ export function extractUnits(cardText, { max = 200 } = {}) {
|
|
|
159
234
|
// 普通段落也算命题;但太短的行多半是标题或噪音。
|
|
160
235
|
// 例外:以"你是/我叫/本体是"开头的短句就是身份,不能因为短就丢。
|
|
161
236
|
if (line.length >= 8 || IDENTITY_RE.test(line)) text = line;
|
|
237
|
+
else { drop(line, 'too-short-line'); continue; }
|
|
162
238
|
}
|
|
163
|
-
if (!text) continue;
|
|
239
|
+
if (!text) { drop(line, 'heading-ish'); continue; }
|
|
164
240
|
|
|
165
241
|
// 「你不要:xxx」这种是反例,不是她
|
|
166
|
-
if (/^(你不要|也不要|你可以|或者:)/.test(text)) continue;
|
|
242
|
+
if (/^(你不要|也不要|你可以|或者:)/.test(text)) { drop(text, 'counter-example'); continue; }
|
|
167
243
|
|
|
168
244
|
const clean = plainText(text);
|
|
169
245
|
let kind = 'trait';
|
|
@@ -184,15 +260,51 @@ export function extractUnits(cardText, { max = 200 } = {}) {
|
|
|
184
260
|
return units;
|
|
185
261
|
}
|
|
186
262
|
|
|
263
|
+
/**
|
|
264
|
+
* 卡体检:告诉你这份卡会被怎么读。
|
|
265
|
+
*
|
|
266
|
+
* 真实用户的卡往往是「人设 + 工具说明 + 红线 + 语气规则」混在一份 md 里,
|
|
267
|
+
* 抽命题时会把"怎么调用 doubao_style_lock"也抽成"她是谁"。
|
|
268
|
+
* 这个函数不猜,只如实分类,然后把该拆出去的段落指出来。
|
|
269
|
+
*/
|
|
270
|
+
export function lintCard(cardText) {
|
|
271
|
+
const trace = [];
|
|
272
|
+
const units = extractUnits(cardText, { log: (l) => trace.push(l) });
|
|
273
|
+
|
|
274
|
+
const kept = trace.filter((l) => l.kept);
|
|
275
|
+
const dropped = trace.filter((l) => !l.kept);
|
|
276
|
+
|
|
277
|
+
// 像"操作手册"的行:讲工具、参数、步骤、调用
|
|
278
|
+
const OPS_RE = /(工具|参数|调用|返回值|命令|步骤|流程|接口|配置|json|yaml|npm|dsh |插件|安装|路径|http|api|shell|脚本|报错|日志)/i;
|
|
279
|
+
const opsLines = kept.filter((l) => OPS_RE.test(l.text));
|
|
280
|
+
const opsSections = [...new Set(opsLines.map((l) => l.section).filter(Boolean))];
|
|
281
|
+
|
|
282
|
+
return {
|
|
283
|
+
units: units.length,
|
|
284
|
+
byKind: units.reduce((acc, u) => { acc[u.kind] = (acc[u.kind] ?? 0) + 1; return acc; }, {}),
|
|
285
|
+
kept: kept.map((l) => ({ text: l.text, kind: l.kind, section: l.section })),
|
|
286
|
+
dropped: dropped.map((l) => ({ text: l.text.slice(0, 60), reason: l.reason })),
|
|
287
|
+
/** 这些行更像"操作手册",建议拆到单独文件,别留在人设里 */
|
|
288
|
+
suggestSplit: opsLines.map((l) => ({ text: l.text.slice(0, 80), section: l.section })),
|
|
289
|
+
suggestSplitSections: opsSections,
|
|
290
|
+
/** 命题预览:抽完之后她到底"是谁" */
|
|
291
|
+
preview: units.slice(0, 20).map((u) => `${u.id} [${u.kind}] ${u.text}`),
|
|
292
|
+
};
|
|
293
|
+
}
|
|
294
|
+
|
|
187
295
|
/**
|
|
188
296
|
* 一条鱼从一张人设卡出生。
|
|
189
297
|
* 同一张卡 → 同一组 units(确定性,可回放)。
|
|
190
298
|
*/
|
|
191
299
|
export function birthFromCard(cardText, { traitsOverride = null } = {}) {
|
|
192
300
|
const auto = extractTraits(cardText);
|
|
301
|
+
const open = extractOpenTraits(cardText, { known: auto });
|
|
193
302
|
const hinted = applyTraitHints(auto, cardText);
|
|
194
303
|
return {
|
|
195
|
-
|
|
304
|
+
// 已知 12 维 + 她自己长出来的开放维度(同名时以手写覆盖为准)
|
|
305
|
+
traits: { ...auto, ...open, ...hinted, ...(traitsOverride ?? {}) },
|
|
306
|
+
knownTraits: auto,
|
|
307
|
+
openTraits: open,
|
|
196
308
|
units: extractUnits(cardText),
|
|
197
309
|
};
|
|
198
310
|
}
|