From e60d1ff19b595a3ac7b7b9443a181f2d28da2bd3 Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:59:43 +0800 Subject: [PATCH] Import packages/plugin/tests/antigravity-transcript-loader.test.ts --- .../antigravity-transcript-loader.test.ts | 284 ++++++++++++++++++ 1 file changed, 284 insertions(+) create mode 100644 packages/plugin/tests/antigravity-transcript-loader.test.ts diff --git a/packages/plugin/tests/antigravity-transcript-loader.test.ts b/packages/plugin/tests/antigravity-transcript-loader.test.ts new file mode 100644 index 0000000..0b5c6fe --- /dev/null +++ b/packages/plugin/tests/antigravity-transcript-loader.test.ts @@ -0,0 +1,284 @@ +import { runScenarios } from '../../../scripts/test-scenarios.mjs' +import { createRequire } from 'node:module' +import { afterEach, beforeEach, describe, expect, it } from 'vitest' +import { mkdtemp, mkdir, writeFile, rm, utimes, symlink } from 'node:fs/promises' +import { join } from 'node:path' +import { tmpdir } from 'node:os' +import { pathToFileURL } from 'node:url' +import { + discoverAntigravitySessions, + discoverAntigravityWorkspaces, + loadTranscriptEvents, +} from '../src/acp/adapters/antigravity/transcript-loader.js' + +let base: string + +const prepareContract1 = async () => { + base = await mkdtemp(join(tmpdir(), 'agy-transcript-test-')) +} +beforeEach(prepareContract1) + +const cleanupContract2 = async () => { + await rm(base, { recursive: true, force: true }) +} +afterEach(cleanupContract2) + +async function writeTranscript(conversationId: string, records: unknown[]): Promise { + const logs = join(base, conversationId, '.system_generated', 'logs') + await mkdir(logs, { recursive: true }) + const path = join(logs, 'transcript.jsonl') + await writeFile(path, records.map(record => JSON.stringify(record)).join('\n') + '\n') + return path +} + +function createDatabase() { + const { DatabaseSync } = createRequire(import.meta.url)('node:sqlite') as typeof import('node:sqlite') + const dbPath = join(base, 'summaries.db') + const db = new DatabaseSync(dbPath) + db.exec('CREATE TABLE conversation_summaries (conversation_id TEXT, title TEXT, workspace_uris TEXT, step_count INTEGER, last_modified_time TEXT)') + return { db, dbPath } +} + +const createdAt = '2026-10-07T00:00:00Z' + +describe('TranscriptLoader', () => { + it('hydrates durable timestamps, messages and tool identities', async () => { + await runScenarios( + [ + { + name: 'restores the durable turn end timestamp instead of the history read time', + run: async () => { + await writeTranscript('conversation', [ + { type: 'USER_INPUT', step_index: 1, created_at: '2026-09-29T09:10:00Z', content: 'ping' }, + { type: 'PLANNER_RESPONSE', step_index: 2, created_at: '2026-09-29T09:10:04Z', content: 'pong' }, + ]) + const events = await loadTranscriptEvents('conversation', 'acp:conversation', base) + expect(events.at(-1)?.event).toMatchObject({ + type: 'turn/end', + time: Date.parse('2026-09-29T09:10:04Z'), + }) + expect(await loadTranscriptEvents('conversation', 'acp:conversation', base)).toEqual(events) + }, + }, + { + name: 'hydrates user and assistant messages from an isolated transcript', + run: async () => { + await writeTranscript('fixture-conversation', [ + { + type: 'USER_INPUT', + step_index: 1, + created_at: createdAt, + content: '\n这个主机咋样\n', + }, + { type: 'PLANNER_RESPONSE', step_index: 2, created_at: createdAt, content: '主机状态正常。' }, + ]) + const events = await loadTranscriptEvents( + 'fixture-conversation', + 'antigravity:fixture-conversation', + base, + ) + expect(events.find((e) => e.event.type === 'user/message')?.event.data).toMatchObject({ + content: [{ type: 'text', text: '这个主机咋样' }], + }) + expect(events.find((e) => e.event.type === 'assistant/message')?.event.data).toMatchObject({ + message: { content: [{ type: 'text', text: '主机状态正常。' }] }, + stream: [], + }) + }, + }, + { + name: 'hydrates tool calls with a valid name and callId, including unnamed tools', + run: async () => { + await writeTranscript('tool-conversation', [ + { type: 'USER_INPUT', step_index: 1, created_at: createdAt, content: 'Run the tool' }, + { + type: 'PLANNER_RESPONSE', + step_index: 2, + created_at: createdAt, + tool_calls: [{ name: 'view_file', args: { path: 'fixture.txt' } }, { args: {} }], + }, + ]) + const events = await loadTranscriptEvents( + 'tool-conversation', + 'antigravity:tool-conversation', + base, + ) + const toolCalls = events.filter((e) => e.event.type === 'tool/call') + expect(toolCalls.map((e) => e.event.data)).toMatchObject([ + { name: 'view_file', callId: '2:view_file' }, + { name: 'tool', callId: '2:tool' }, + ]) + }, + }, + ], + async () => { + await cleanupContract2() + await prepareContract1() + }, + ) + }, 15000) + + it('discovers workspace-scoped sessions from isolated durable sources', async () => { + await runScenarios( + [ + { + name: 'recovers workspace-scoped durable conversations with empty AGY summaries', + run: async () => { + const workspace = join(base, 'project') + const other = join(base, 'other') + const empty = join(base, 'empty') + for (const path of [workspace, other, empty]) await mkdir(path) + const { db, dbPath } = createDatabase() + try { + const insert = db.prepare('INSERT INTO conversation_summaries VALUES (?, ?, ?, ?, ?)') + for (const [id, path] of [ + ['stale-session', workspace], + ['other-session', other], + ['idle-session', empty], + ['active-untitled', workspace], + ]) { + insert.run(id, '', JSON.stringify([pathToFileURL(path).href]), 0, createdAt) + } + db.prepare('UPDATE conversation_summaries SET step_count = 2 WHERE conversation_id = ?').run( + 'active-untitled', + ) + insert.run( + 'normal-session', + 'Normal', + JSON.stringify([pathToFileURL(workspace).href]), + 2, + createdAt, + ) + } finally { + db.close() + } + for (const id of ['stale-session', 'other-session', 'active-untitled']) { + await writeTranscript(id, [ + { type: 'USER_INPUT', step_index: 1, created_at: createdAt, content: 'Durable message' }, + ]) + } + const sessions = await discoverAntigravitySessions(workspace, 30, base, dbPath) + expect(sessions.map((session) => session.conversationId).sort()).toEqual([ + 'active-untitled', + 'normal-session', + 'stale-session', + ]) + expect(sessions.find((session) => session.conversationId === 'stale-session')?.title).toBe( + 'Durable message', + ) + expect(sessions.find((session) => session.conversationId === 'active-untitled')?.title).toBe( + 'Durable message', + ) + expect((await discoverAntigravityWorkspaces(dbPath, base)).sort()).toEqual( + [workspace, other].sort(), + ) + }, + }, + { + name: 'discovers sessions from an isolated brain directory when the database is missing', + run: async () => { + for (const [id, title, time] of [ + ['older-session', 'Older conversation', 1_000], + ['newer-session', 'Newer conversation', 2_000], + ] as const) { + const path = await writeTranscript(id, [ + { type: 'USER_INPUT', step_index: 1, created_at: createdAt, content: title }, + ]) + await utimes(path, time, time) + } + const dbPath = join(base, 'missing.db') + const sessions = await discoverAntigravitySessions('', 10, base, dbPath) + expect(sessions).toMatchObject([ + { conversationId: 'newer-session', title: 'Newer conversation', updatedAt: 2_000_000 }, + { conversationId: 'older-session', title: 'Older conversation', updatedAt: 1_000_000 }, + ]) + expect(await discoverAntigravitySessions('', 1, base, dbPath)).toEqual(sessions.slice(0, 1)) + }, + }, + { + name: 'discovers only existing project directories from an isolated database', + run: async () => { + const project = join(base, 'project with spaces') + const file = join(base, 'not-a-directory') + await mkdir(project) + await writeFile(file, 'fixture') + const { db, dbPath } = createDatabase() + try { + const insert = db.prepare('INSERT INTO conversation_summaries VALUES (?, ?, ?, ?, ?)') + insert.run( + 'project-session', + 'Project', + JSON.stringify([ + pathToFileURL(project).href, + pathToFileURL(project).href, + pathToFileURL(file).href, + pathToFileURL(join(base, 'missing-project')).href, + 'https://example.invalid/project', + ]), + 2, + createdAt, + ) + insert.run('malformed-session', 'Malformed', 'not-json', 2, createdAt) + } finally { + db.close() + } + expect(await discoverAntigravityWorkspaces(dbPath, base)).toEqual([project]) + }, + }, + { + name: 'matches decoded workspace URIs exactly and applies the limit after scoping', + run: async () => { + const project = join(base, '项目 with spaces') + const other = `${project}-other` + const { db, dbPath } = createDatabase() + try { + const insert = db.prepare('INSERT INTO conversation_summaries VALUES (?, ?, ?, ?, ?)') + insert.run( + 'foreign-session', + 'Foreign', + JSON.stringify([pathToFileURL(other).href]), + 2, + '2026-10-07T00:01:00Z', + ) + insert.run('local-session', 'Local', JSON.stringify([pathToFileURL(project).href]), 2, createdAt) + insert.run('malformed-session', 'Malformed', 'not-json', 2, createdAt) + } finally { + db.close() + } + expect(await discoverAntigravitySessions(project, 1, base, dbPath)).toMatchObject([ + { conversationId: 'local-session', title: 'Local' }, + ]) + expect(await discoverAntigravitySessions(join(base, 'unrelated'), 10, base, dbPath)).toEqual([]) + }, + }, + { + name: 'does not infer a workspace from unrelated transcripts when the database is missing', + run: async () => { + await writeTranscript('foreign-session', [ + { type: 'USER_INPUT', step_index: 1, created_at: createdAt, content: 'Foreign' }, + ]) + expect( + await discoverAntigravitySessions(join(base, 'project'), 10, base, join(base, 'missing.db')), + ).toEqual([]) + }, + }, + ], + async () => { + await cleanupContract2() + await prepareContract1() + }, + ) + }, 25000) + + it('rejects traversal and symlinked transcripts outside the AGY brain', async () => { + await writeTranscript('outside-session', [{ type: 'USER_INPUT', step_index: 1, created_at: createdAt, content: 'Outside' }]) + const brain = join(base, 'brain') + await mkdir(brain) + await symlink(join(base, 'outside-session'), join(brain, 'linked-session'), process.platform === 'win32' ? 'junction' : 'dir') + expect(await loadTranscriptEvents('../outside-session', 'remote', brain)).toEqual([]) + expect(await loadTranscriptEvents('..\\outside-session', 'remote', brain)).toEqual([]) + expect(await loadTranscriptEvents('linked-session', 'remote', brain)).toEqual([]) + expect(await discoverAntigravitySessions('', 10, brain, join(base, 'missing.db'))).toEqual([]) + }) + +})