403 lines
22 KiB
TypeScript
403 lines
22 KiB
TypeScript
// @vitest-environment node
|
|
import { afterEach, describe, expect, it, vi } from 'vitest';
|
|
import { mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
|
|
import { tmpdir } from 'node:os';
|
|
import path from 'node:path';
|
|
import { TeacherTopicStore } from '../../electron/coding-teacher/store';
|
|
import { applyTeacherReply } from '../../electron/coding-teacher/reply';
|
|
import { compileTeacherContext, teacherHistoryMessages } from '../../electron/coding-teacher/context';
|
|
import { createTeacherReadTools } from '../../electron/coding-teacher/read-tools';
|
|
import type { TeacherDefinition, TeacherRequest, TeacherSourceContext, TeacherTopic } from '../../shared/coding-teacher';
|
|
|
|
const roots: string[] = [];
|
|
afterEach(async () => {
|
|
for (const root of roots.splice(0)) await rm(root, { recursive: true, force: true });
|
|
});
|
|
|
|
const definition: TeacherDefinition = {
|
|
config_id: 'selected-agent', schema_version: 1, teacher_id: 'published-agent',
|
|
name: '当前智能体', description: '', avatar_id: 'avatar-01', welcome_message: '',
|
|
suggested_questions: [], system_prompt: '使用已发布配置中的职责。', skills: [],
|
|
model: { model_id: 'model', reasoning_choice: { mode: 'default' } },
|
|
limits: { max_input_tokens: 32000, max_output_tokens: 1500 },
|
|
};
|
|
const source: TeacherSourceContext = {
|
|
messages: [{ id: 'source-message', role: 'assistant', text: '玩家已经能走到门口。' }],
|
|
cursor: { workerGeneration: 1, seq: 3 }, capturedAt: '2026-09-28T01:00:00Z',
|
|
};
|
|
const marker = (field: string) => 'ARCHIVED_ONLY_' + field;
|
|
const ideas = {
|
|
kind: 'ideas', title: marker('ideas'),
|
|
items: [{ id: 'door', text: marker('idea-text'), state: 'kept' }], firstItemId: 'door',
|
|
};
|
|
const structure = {
|
|
kind: 'structure', title: marker('structure'), nodes: [{ id: 'door', label: marker('structure-label') }],
|
|
};
|
|
const flow = {
|
|
kind: 'flow', title: marker('flow'),
|
|
nodes: [{ id: 'door', label: marker('flow-label'), kind: 'event' }], edges: [],
|
|
};
|
|
const comparison = {
|
|
kind: 'comparison', title: marker('comparison'),
|
|
columns: [{ id: 'a', label: marker('column-a') }, { id: 'b', label: marker('column-b') }],
|
|
rows: [{ id: 'first', label: marker('row'), cells: [
|
|
{ columnId: 'a', text: marker('cell-a') }, { columnId: 'b', text: marker('cell-b') },
|
|
] }],
|
|
};
|
|
const archivedCases = [
|
|
...[ideas, structure, flow, comparison].map(content => ({
|
|
name: content.kind,
|
|
discussion: {
|
|
id: 'b8a278e5-a5ce-45fc-af92-d39d8fd48ebf', revision: 7, status: 'active',
|
|
content, previousIdeas: ideas, previousStructure: structure,
|
|
},
|
|
context: { toolId: 'b8a278e5-a5ce-45fc-af92-d39d8fd48ebf', revision: 7, focusId: 'door' },
|
|
snapshot: content,
|
|
})),
|
|
{
|
|
name: 'invalid legacy fields',
|
|
discussion: {
|
|
id: marker('invalid-id'), revision: -4, status: marker('invalid-status'),
|
|
content: { kind: marker('unknown-kind') },
|
|
previousIdeas: [marker('invalid-previousIdeas')], previousStructure: marker('invalid-previousStructure'),
|
|
unknownArchiveField: { retained: marker('unknown-field') },
|
|
},
|
|
context: { toolId: marker('context-id'), revision: 'invalid', transition: marker('context-transition') },
|
|
snapshot: { kind: 'flow', nodes: marker('invalid-snapshot') },
|
|
},
|
|
{ name: 'legacy scalar', discussion: marker('scalar'), context: marker('scalar-context'), snapshot: 42 },
|
|
{ name: 'legacy array', discussion: [marker('array')], context: [marker('array-context')], snapshot: [marker('array-snapshot')] },
|
|
{ name: 'legacy null', discussion: null, context: null, snapshot: null },
|
|
];
|
|
|
|
function request(overrides: Partial<TeacherRequest> = {}): TeacherRequest {
|
|
return {
|
|
id: 'completed-turn', text: '进门后要让玩家看见什么？', references: [],
|
|
createdAt: source.capturedAt, sourceCursor: source.cursor, sourceCapturedAt: source.capturedAt,
|
|
includedSourceMessageIds: ['source-message'], omittedMessages: 0, status: 'completed',
|
|
response: '先看进门时的提示。\n\n```json\n{"kind":"flow","label":"普通代码示例"}\n```',
|
|
suggestedQuestions: ['→ 看看提示出现的时机', '↪ 我想先说说玩家会看到什么'],
|
|
presentation: 'discussion-v1', discussionError: marker('error'), unparsedResponse: marker('unparsed'),
|
|
cloudRequestId: 'cloud-history-request',
|
|
toolActivity: [{ id: 'read-1', name: 'read_project_file', status: 'completed' }],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function topic(archive = archivedCases[0]): TeacherTopic {
|
|
return {
|
|
schemaVersion: 1, revision: 12, id: 'e6ba57d5-9dc0-49fb-a8cf-e911f9ea366b',
|
|
accountId: 'account', projectId: 'project', sourceConversationId: 'project', version: 31,
|
|
definition, createdAt: source.capturedAt, updatedAt: source.capturedAt,
|
|
discussion: structuredClone(archive.discussion),
|
|
requests: [request({
|
|
discussionContext: structuredClone(archive.context), discussionSnapshot: structuredClone(archive.snapshot),
|
|
})],
|
|
};
|
|
}
|
|
|
|
async function fixture(value: TeacherTopic) {
|
|
const root = await mkdtemp(path.join(tmpdir(), 'teacher-reply-history-'));
|
|
roots.push(root);
|
|
const file = path.join(root, value.id + '.json');
|
|
// Different formatting also detects an unnecessary atomic JSON rewrite.
|
|
const raw = JSON.stringify(value, null, 4) + '\n\n';
|
|
await writeFile(file, raw);
|
|
const before = await stat(file, { bigint: true });
|
|
const unchanged = async () => {
|
|
expect(await readFile(file, 'utf8')).toBe(raw);
|
|
const after = await stat(file, { bigint: true });
|
|
expect({ ino: after.ino, mtimeNs: after.mtimeNs }).toEqual({ ino: before.ino, mtimeNs: before.mtimeNs });
|
|
};
|
|
return { root, file, unchanged, store: new TeacherTopicStore(root) };
|
|
}
|
|
|
|
describe('passive teacher reply history compatibility', () => {
|
|
it('retains all four historical shortcuts through read, list and a later save', async () => {
|
|
const original = topic(archivedCases[4]);
|
|
const historicalReplies = [
|
|
'看懂规则｜摸头会改变什么？',
|
|
'想想作用｜我们聊聊摸头的作用。',
|
|
'试试结果｜怎样知道变化发生了？',
|
|
'换个话题｜我想先聊别的地方。',
|
|
];
|
|
original.requests[0].suggestedQuestions = historicalReplies;
|
|
const f = await fixture(original);
|
|
|
|
const loaded = await f.store.read(original.id);
|
|
expect(loaded).toEqual(original);
|
|
expect(loaded.requests[0].suggestedQuestions).toEqual(historicalReplies);
|
|
expect((await f.store.list()).items).toEqual([{
|
|
id: original.id, title: original.requests[0].text, updatedAt: original.updatedAt,
|
|
version: 31, teacherId: 'selected-agent',
|
|
}]);
|
|
expect(await new TeacherTopicStore(f.root).read(original.id)).toEqual(original);
|
|
await f.unchanged();
|
|
|
|
loaded.revision++;
|
|
loaded.requests.push(request({ id: 'new-turn', presentation: 'reply-v1', suggestedQuestions: [],
|
|
discussionError: undefined, unparsedResponse: undefined }));
|
|
await f.store.save(loaded);
|
|
const expected = JSON.parse(JSON.stringify({ ...original,
|
|
revision: original.revision + 1, requests: [...original.requests, loaded.requests[1]],
|
|
}));
|
|
const saved = JSON.parse(await readFile(f.file, 'utf8'));
|
|
expect(saved).toEqual(expected);
|
|
expect(saved.requests[0].suggestedQuestions).toEqual(historicalReplies);
|
|
expect(await new TeacherTopicStore(f.root).read(original.id)).toEqual(expected);
|
|
});
|
|
|
|
it.each(archivedCases)('keeps $name opaque through read, list and a later save', async archive => {
|
|
const original = topic(archive);
|
|
const f = await fixture(original);
|
|
const loaded = await f.store.read(original.id);
|
|
expect(loaded).toEqual(original);
|
|
expect(await new TeacherTopicStore(f.root).list()).toEqual({
|
|
items: [{ id: original.id, title: original.requests[0].text, updatedAt: original.updatedAt,
|
|
version: 31, teacherId: 'selected-agent' }],
|
|
lastSelectedTopicId: original.id,
|
|
});
|
|
await f.unchanged();
|
|
|
|
loaded.revision++;
|
|
loaded.requests.push(request({ id: 'new-turn', presentation: 'reply-v1',
|
|
discussionError: undefined, unparsedResponse: undefined }));
|
|
await f.store.save(loaded);
|
|
const saved = JSON.parse(await readFile(f.file, 'utf8'));
|
|
expect(saved).toEqual(JSON.parse(JSON.stringify({ ...original,
|
|
revision: original.revision + 1, requests: [...original.requests, loaded.requests[1]],
|
|
})));
|
|
expect(await new TeacherTopicStore(f.root).read(original.id)).toEqual(saved);
|
|
});
|
|
|
|
it.each(['preparing', 'running'] as const)('recovers %s without interpreting or discarding archived data', async status => {
|
|
const original = topic(archivedCases[4]);
|
|
original.requests.push(...(['failed', 'cancelled', 'interrupted', status] as const).map((value, index) =>
|
|
request({ ...original.requests[0], id: 'turn-' + index, status: value, error: 'existing error ' + index })));
|
|
const f = await fixture(original);
|
|
const expected = structuredClone(original);
|
|
expected.revision++;
|
|
expected.requests.at(-1)!.status = 'interrupted';
|
|
expected.requests.at(-1)!.error = '应用已重启，本次回复中断。';
|
|
|
|
const loaded = await f.store.read(original.id);
|
|
expect(loaded).toEqual({ ...expected, unsaved: false });
|
|
expect(JSON.parse(await readFile(f.file, 'utf8'))).toEqual(expected);
|
|
const recovered = await stat(f.file, { bigint: true });
|
|
const reloadedStore = new TeacherTopicStore(f.root);
|
|
expect(await reloadedStore.read(original.id)).toEqual(expected);
|
|
await reloadedStore.list();
|
|
const reread = await stat(f.file, { bigint: true });
|
|
expect({ ino: reread.ino, mtimeNs: reread.mtimeNs }).toEqual({ ino: recovered.ino, mtimeNs: recovered.mtimeNs });
|
|
});
|
|
|
|
it('projects completed prose and unchanged quick replies without leaking archived fields into model context', () => {
|
|
const original = topic(archivedCases[4]);
|
|
original.requests.push(request({ id: 'check-in', intent: 'check-in', text: marker('synthetic-check-in-question'),
|
|
response: '项目进展提醒正文。', suggestedQuestions: ['→ 继续这个角度'] }));
|
|
original.requests.push(...(['preparing', 'running', 'failed', 'cancelled', 'interrupted'] as const).map(status =>
|
|
request({ id: status, status, text: marker(status), response: marker(status + '-response') })));
|
|
const before = structuredClone(original);
|
|
const history = teacherHistoryMessages(original.requests);
|
|
expect(history.map(message => [message.id, message.role])).toEqual([
|
|
['teacher:completed-turn:user', 'user'], ['teacher:completed-turn:assistant', 'assistant'],
|
|
['teacher:check-in:assistant', 'assistant'],
|
|
]);
|
|
expect(history[0].text).toBe(original.requests[0].text);
|
|
expect(history[1].text).toContain(original.requests[0].response);
|
|
for (const quickReply of original.requests[0].suggestedQuestions!) expect(history[1].text).toContain(quickReply);
|
|
expect(history[2].text).toContain('项目进展提醒正文。');
|
|
expect(history[2].text).toContain('→ 继续这个角度');
|
|
expect(JSON.stringify(history)).not.toContain('ARCHIVED_ONLY_');
|
|
|
|
const compiled = compileTeacherContext(definition, source, original.requests, '接着看这个角度', []);
|
|
const serialized = JSON.stringify(compiled.messages);
|
|
expect(serialized).not.toContain('ARCHIVED_ONLY_');
|
|
for (const message of history) expect(compiled.messages.some(item => item.content.includes(message.text))).toBe(true);
|
|
expect(original).toEqual(before);
|
|
});
|
|
|
|
it('exposes only the same readable history through conversation index and message reads', async () => {
|
|
const original = topic(archivedCases[4]);
|
|
const f = await fixture(original);
|
|
const loaded = await f.store.read(original.id);
|
|
const assertCurrent = vi.fn();
|
|
const tools = createTeacherReadTools({ projectPath: f.root, source, history: loaded.requests, assertCurrent });
|
|
const signal = new AbortController().signal;
|
|
const index = await tools.execute('read_conversation', '{}', signal);
|
|
expect(index).toContain('teacher:completed-turn:assistant');
|
|
expect(index).not.toContain('ARCHIVED_ONLY_');
|
|
for (const message of teacherHistoryMessages(loaded.requests)) {
|
|
const raw = await tools.execute('read_conversation', JSON.stringify({ message_id: message.id }), signal);
|
|
expect(JSON.parse(raw).text).toBe(message.text);
|
|
expect(raw).not.toContain('ARCHIVED_ONLY_');
|
|
}
|
|
const inaccessible = await tools.executeResult('read_conversation',
|
|
JSON.stringify({ message_id: 'discussion' }), signal);
|
|
expect(inaccessible.status).toBe('error');
|
|
expect(inaccessible.content).not.toContain('ARCHIVED_ONLY_');
|
|
expect(assertCurrent).toHaveBeenCalled();
|
|
expect(loaded).toEqual(original);
|
|
await f.unchanged();
|
|
});
|
|
});
|
|
|
|
describe('local repair of retained teacher replies', () => {
|
|
const completeReply = '它早就不是"刚搭好架子"那种阶段了——骨架、玩法、成长线都在跑。\n现在更需要打磨细节。';
|
|
const quoteRaw = '{"reply":"' + completeReply
|
|
+ '","quickReplies":["看看接下来做什么"],"tool":{"kind":"structure","nodes":[{"id":"core","label":"完整结构"}]}}';
|
|
|
|
it('repairs the screenshot-style quoted prose in a cached read without rewriting or replaying history', async () => {
|
|
const original = topic(archivedCases[4]);
|
|
original.requests[0] = request({ ...original.requests[0], response: '它早就不是',
|
|
unparsedResponse: quoteRaw, replyParseError: '旧解析错误', replyIncomplete: true,
|
|
usage: { inputTokens: 20, outputTokens: 40, cacheReadTokens: 5, cacheWriteTokens: 3 } });
|
|
const f = await fixture(original);
|
|
const loaded = await f.store.read(original.id);
|
|
const repaired = loaded.requests[0];
|
|
expect(repaired).toEqual({ ...original.requests[0], response: completeReply,
|
|
suggestedQuestions: ['看看接下来做什么'], discussionError: undefined,
|
|
replyParseError: undefined, replyIncomplete: undefined });
|
|
expect(loaded).toEqual({ ...original, requests: [repaired] });
|
|
expect(repaired.unparsedResponse).toBe(quoteRaw);
|
|
expect(repaired.status).toBe('completed');
|
|
expect(repaired.discussionContext).toEqual(original.requests[0].discussionContext);
|
|
expect(repaired.discussionSnapshot).toEqual(original.requests[0].discussionSnapshot);
|
|
expect(await f.store.read(original.id)).toBe(loaded);
|
|
expect(await new TeacherTopicStore(f.root).read(original.id)).toEqual(loaded);
|
|
await f.unchanged();
|
|
|
|
// A later ordinary save can retain the repaired projection, with the exact
|
|
// original response and all opaque data still available for diagnosis.
|
|
await f.store.save(loaded);
|
|
const persisted = JSON.parse(await readFile(f.file, 'utf8'));
|
|
expect(persisted.requests[0].unparsedResponse).toBe(quoteRaw);
|
|
expect(persisted.requests[0].response).toBe(completeReply);
|
|
expect(await new TeacherTopicStore(f.root).read(original.id)).toEqual(persisted);
|
|
});
|
|
|
|
it('keeps complete prose when auxiliary suggestions or legacy payloads remain invalid', async () => {
|
|
const original = topic();
|
|
const raw = '{"reply":"这是一段完整回答。","quickReplies":[42],"tool":';
|
|
original.requests[0] = request({ response: '这是一段完整回答。', unparsedResponse: raw,
|
|
replyParseError: '旧解析错误', replyIncomplete: true });
|
|
const f = await fixture(original);
|
|
const loaded = await f.store.read(original.id);
|
|
expect(loaded.requests[0]).toMatchObject({ status: 'completed', response: '这是一段完整回答。',
|
|
suggestedQuestions: [], unparsedResponse: raw, replyParseError: expect.any(String) });
|
|
expect(loaded.requests[0].replyIncomplete).toBeUndefined();
|
|
expect(await new TeacherTopicStore(f.root).read(original.id)).toEqual(loaded);
|
|
await f.unchanged();
|
|
});
|
|
|
|
it('repairs display after saving restart recovery without rewriting a completed reply on disk', async () => {
|
|
const original = topic();
|
|
original.requests[0] = request({ response: '它早就不是', unparsedResponse: quoteRaw });
|
|
original.requests.push(request({ id: 'running-turn', status: 'running', response: '' }));
|
|
const f = await fixture(original);
|
|
const loaded = await f.store.read(original.id);
|
|
expect(loaded.requests[0].response).toBe(completeReply);
|
|
expect(loaded.requests[1].status).toBe('interrupted');
|
|
const persisted = JSON.parse(await readFile(f.file, 'utf8'));
|
|
expect(persisted.requests[0]).toEqual(original.requests[0]);
|
|
expect(persisted.requests[1].status).toBe('interrupted');
|
|
expect(persisted.revision).toBe(original.revision + 1);
|
|
expect((await new TeacherTopicStore(f.root).read(original.id)).requests[0].response).toBe(completeReply);
|
|
});
|
|
|
|
it('keeps the question but excludes incomplete prose and suggestions from model context and read tools', async () => {
|
|
const original = topic();
|
|
original.requests[0] = request({ response: '它早就不是',
|
|
unparsedResponse: '{"reply":"它早就不是"刚搭好架子', suggestedQuestions: ['尚未确认的建议'] });
|
|
const f = await fixture(original);
|
|
const loaded = await f.store.read(original.id);
|
|
expect(loaded.requests[0].replyIncomplete).toBe(true);
|
|
expect(teacherHistoryMessages(loaded.requests)).toEqual([
|
|
{ id: 'teacher:completed-turn:user', role: 'user', text: original.requests[0].text },
|
|
]);
|
|
const context = JSON.stringify(compileTeacherContext(definition, source, loaded.requests, '重新看看', []).messages);
|
|
expect(context).toContain(original.requests[0].text);
|
|
expect(context).not.toMatch(/它早就不是|尚未确认的建议/);
|
|
const tools = createTeacherReadTools({ projectPath: f.root, source, history: loaded.requests, assertCurrent: vi.fn() });
|
|
const signal = new AbortController().signal;
|
|
const index = await tools.execute('read_conversation', '{}', signal);
|
|
expect(index).toContain('teacher:completed-turn:user');
|
|
expect(index).not.toContain('teacher:completed-turn:assistant');
|
|
const assistant = await tools.executeResult('read_conversation', JSON.stringify({ message_id: 'teacher:completed-turn:assistant' }), signal);
|
|
expect(assistant.status).toBe('error');
|
|
expect(assistant.content).not.toContain('它早就不是');
|
|
await f.unchanged();
|
|
});
|
|
|
|
it('marks truly truncated prose incomplete without replacing the saved text or raw evidence', async () => {
|
|
const original = topic();
|
|
original.requests[0] = request({ response: '它早就不是',
|
|
unparsedResponse: '{"reply":"它早就不是"刚搭好架子', replyParseError: '旧解析错误' });
|
|
const f = await fixture(original);
|
|
const loaded = await f.store.read(original.id);
|
|
expect(loaded.requests[0]).toEqual({ ...original.requests[0], replyIncomplete: true });
|
|
expect(await new TeacherTopicStore(f.root).read(original.id)).toEqual(loaded);
|
|
await f.unchanged();
|
|
});
|
|
|
|
it.each(['failed', 'cancelled', 'interrupted'] as const)('does not salvage a %s request as success', async status => {
|
|
const original = topic();
|
|
original.requests[0] = request({ status, response: '它早就不是', unparsedResponse: quoteRaw,
|
|
error: '该请求未完成', replyParseError: '旧解析错误' });
|
|
const f = await fixture(original);
|
|
expect(await f.store.read(original.id)).toEqual(original);
|
|
await f.unchanged();
|
|
});
|
|
|
|
it.each(['preparing', 'running'] as const)('keeps restart recovery for %s without accepting its received bytes', async status => {
|
|
const original = topic();
|
|
original.requests[0] = request({ status, response: '它早就不是', unparsedResponse: quoteRaw,
|
|
replyParseError: '旧解析错误' });
|
|
const f = await fixture(original);
|
|
const loaded = await f.store.read(original.id);
|
|
expect(loaded.requests[0]).toEqual({ ...original.requests[0], status: 'interrupted',
|
|
error: '应用已重启，本次回复中断。' });
|
|
expect(loaded.revision).toBe(original.revision + 1);
|
|
expect(await new TeacherTopicStore(f.root).read(original.id)).toMatchObject({ requests: loaded.requests });
|
|
});
|
|
|
|
it('does not replace useful prose with different content from a stale raw archive', async () => {
|
|
const original = topic();
|
|
original.requests[0] = request({ response: '已经保存的完整回答。', unparsedResponse: quoteRaw });
|
|
const f = await fixture(original);
|
|
expect(await f.store.read(original.id)).toEqual(original);
|
|
await f.unchanged();
|
|
});
|
|
|
|
it('also repairs the legacy intro/questions envelope while leaving its tool snapshot opaque', async () => {
|
|
const original = topic();
|
|
const raw = '{"intro":"它早就不是"刚搭好架子"了。","questions":["继续"],"tool":{"kind":"ideas"}}';
|
|
original.requests[0] = request({ response: '它早就不是', unparsedResponse: raw });
|
|
const f = await fixture(original);
|
|
const loaded = await f.store.read(original.id);
|
|
expect(loaded.requests[0]).toMatchObject({ response: '它早就不是"刚搭好架子"了。',
|
|
suggestedQuestions: ['继续'], unparsedResponse: raw });
|
|
expect(loaded.requests[0].discussionError).toBeUndefined();
|
|
expect(loaded.requests[0].discussionSnapshot).toEqual(original.requests[0].discussionSnapshot);
|
|
await f.unchanged();
|
|
});
|
|
|
|
it('propagates incomplete results and retains diagnostics for recovered new replies', () => {
|
|
const current = request({ replyIncomplete: true, replyParseError: '旧解析错误' });
|
|
applyTeacherReply(current, '{"reply":"还没有说完');
|
|
expect(current.replyIncomplete).toBe(true);
|
|
expect(current.replyParseError).toBeTruthy();
|
|
expect(current.unparsedResponse).toBe('{"reply":"还没有说完');
|
|
|
|
applyTeacherReply(current, quoteRaw);
|
|
expect(current.response).toBe(completeReply);
|
|
expect(current.replyIncomplete).toBeUndefined();
|
|
expect(current.replyParseError).toBeUndefined();
|
|
expect(current.discussionError).toBeUndefined();
|
|
expect(current.unparsedResponse).toBe(quoteRaw);
|
|
const recovered = structuredClone(current);
|
|
applyTeacherReply(current, quoteRaw);
|
|
expect(current).toEqual(recovered);
|
|
});
|
|
});
|