| import { afterEach, beforeEach, describe, expect, it } from 'vitest'; |
|
|
| import { SyncDescriptor } from '#/_base/di/descriptors'; |
| import { DisposableStore } from '#/_base/di/lifecycle'; |
| import { TestInstantiationService } from '#/_base/di/test'; |
| import { |
| ContextAppendMessage, |
| ContextUndo, |
| } from '#/agent/contextMemory/contextEvents'; |
| import { IEventBus } from '#/app/event/eventBus'; |
| import { EventBusService } from '#/app/event/eventBusService'; |
| import { |
| PlanModeCancel, |
| PlanModeEnter, |
| PlanModeExit, |
| planKey, |
| PlanRevision, |
| } from '#/features/plan/planOps'; |
| import { AppendLogStore } from '#/persistence/backends/node-fs/appendLogStore'; |
| import { InMemoryStorageService } from '#/persistence/backends/memory/inMemoryStorageService'; |
| import { IAppendLogStore } from '#/persistence/interface/appendLogStore'; |
| import { IFileSystemStorageService } from '#/persistence/interface/storage'; |
| import { IAgentStateService } from '#/agent/state/agentState'; |
| import { IEventDispatcher } from '#/state/eventDispatcher'; |
| import { IWireService } from '#/wire/wire'; |
| import { AGENT_WIRE_RECORD_KEY, type WireRecord } from '#/wire/record'; |
|
|
| import { |
| registerTestAgentWire, |
| registerTestEventDispatcher, |
| restoreTestEventDispatcher, |
| testWireScope, |
| } from '../../wire/stubs'; |
|
|
| const SCOPE = 'wire'; |
| const KEY = 'plan-test'; |
|
|
| let disposables: DisposableStore; |
| let dispatcher: IEventDispatcher; |
| let agentState: IAgentStateService; |
| let log: IAppendLogStore; |
|
|
| interface Host { |
| wire: IWireService; |
| dispatcher: IEventDispatcher; |
| agentState: IAgentStateService; |
| log: IAppendLogStore; |
| eventBus: IEventBus; |
| } |
|
|
| function buildHost(key: string): Host { |
| const ix = disposables.add(new TestInstantiationService()); |
| ix.stub(IFileSystemStorageService, new InMemoryStorageService()); |
| ix.set(IAppendLogStore, new SyncDescriptor(AppendLogStore)); |
| ix.set(IEventBus, new SyncDescriptor(EventBusService)); |
| const wire = registerTestAgentWire(ix, testWireScope(SCOPE, key), { |
| log: ix.get(IAppendLogStore), |
| eventBus: ix.get(IEventBus), |
| }); |
| const dispatcher = registerTestEventDispatcher(ix); |
| const agentState = ix.get(IAgentStateService); |
| agentState.contributeState(planKey); |
| return { wire, dispatcher, agentState, log: ix.get(IAppendLogStore), eventBus: ix.get(IEventBus) }; |
| } |
|
|
| beforeEach(() => { |
| disposables = new DisposableStore(); |
| const host = buildHost(KEY); |
| dispatcher = host.dispatcher; |
| agentState = host.agentState; |
| log = host.log; |
| }); |
|
|
| afterEach(() => disposables.dispose()); |
|
|
| async function readRecords(key = KEY): Promise<WireRecord[]> { |
| await dispatcher.flush(); |
| const out: WireRecord[] = []; |
| for await (const record of log.read<WireRecord>(testWireScope(SCOPE, key), AGENT_WIRE_RECORD_KEY)) { |
| out.push(record); |
| } |
| return out; |
| } |
|
|
| describe('plan ops (wire-backed)', () => { |
| it('enter/cancel/exit drive active state and persist flat records', async () => { |
| expect(agentState.get(planKey).active).toBe(false); |
|
|
| await dispatcher.dispatch(new PlanModeEnter({ agentId: 'test-agent', id: 'p1' })); |
| expect(agentState.get(planKey)).toEqual({ |
| active: true, |
| id: 'p1', |
| }); |
|
|
| await dispatcher.dispatch(new PlanModeCancel({ agentId: 'test-agent', id: 'p1' })); |
| expect(agentState.get(planKey)).toEqual({ active: false }); |
|
|
| await dispatcher.dispatch(new PlanModeEnter({ agentId: 'test-agent', id: 'p2' })); |
| await dispatcher.dispatch(new PlanModeExit({ agentId: 'test-agent' })); |
| expect(agentState.get(planKey).active).toBe(false); |
|
|
| const records = await readRecords(); |
| expect(records.map((record) => record.type)).toEqual([ |
| 'plan_mode.enter', |
| 'plan_mode.cancel', |
| 'plan_mode.enter', |
| 'plan_mode.exit', |
| ]); |
| expect(records.every((record) => 'payload' in record === false)).toBe(true); |
| expect(records[0]).toEqual( |
| expect.objectContaining({ |
| type: 'plan_mode.enter', |
| id: 'p1', |
| }), |
| ); |
| }); |
|
|
| it('cancel and exit both deactivate plan mode but emit distinct record types', async () => { |
| await dispatcher.dispatch(new PlanModeEnter({ agentId: 'test-agent', id: 'p1' })); |
| await dispatcher.dispatch(new PlanModeCancel({ agentId: 'test-agent', id: 'p1' })); |
| expect(agentState.get(planKey)).toEqual({ active: false }); |
|
|
| await dispatcher.dispatch(new PlanModeEnter({ agentId: 'test-agent', id: 'p2' })); |
| await dispatcher.dispatch(new PlanModeExit({ agentId: 'test-agent', id: 'p2' })); |
| expect(agentState.get(planKey)).toEqual({ active: false }); |
|
|
| const records = await readRecords(); |
| expect(records.map((record) => record.type)).toEqual([ |
| 'plan_mode.enter', |
| 'plan_mode.cancel', |
| 'plan_mode.enter', |
| 'plan_mode.exit', |
| ]); |
| expect(records[1]).toEqual(expect.objectContaining({ type: 'plan_mode.cancel', id: 'p1' })); |
| expect(records[3]).toEqual(expect.objectContaining({ type: 'plan_mode.exit', id: 'p2' })); |
| }); |
|
|
| it('apply returns the same reference on a no-op (gate stays quiet)', async () => { |
| const initial = agentState.get(planKey); |
| await dispatcher.dispatch(new PlanModeCancel({ agentId: 'test-agent' })); |
| expect(agentState.get(planKey)).toBe(initial); |
|
|
| await dispatcher.dispatch(new PlanModeEnter({ agentId: 'test-agent', id: 'p1' })); |
| const active = agentState.get(planKey); |
| await dispatcher.dispatch(new PlanModeEnter({ agentId: 'test-agent', id: 'p1' })); |
| expect(agentState.get(planKey)).toBe(active); |
| }); |
|
|
| it('ignores an invalid undo count without corrupting checkpoint state', async () => { |
| await dispatcher.dispatch( |
| new ContextAppendMessage({ |
| agentId: 'test-agent', |
| message: { |
| role: 'user', |
| content: [{ type: 'text', text: 'keep me' }], |
| toolCalls: [], |
| origin: { kind: 'user' }, |
| }, |
| }), |
| ); |
| const checkpointed = agentState.get(planKey); |
|
|
| await dispatcher.dispatch(new ContextUndo({ agentId: 'test-agent', count: 0.5 })); |
|
|
| expect(agentState.get(planKey)).toBe(checkpointed); |
| expect(agentState.get(planKey)).toEqual({ active: false }); |
| }); |
|
|
| it('replay rebuilds active state silently', async () => { |
| await dispatcher.dispatch(new PlanModeEnter({ agentId: 'test-agent', id: 'p1' })); |
| const records = await readRecords(); |
|
|
| const host = buildHost('plan-replay'); |
| const emissions: string[] = []; |
| host.eventBus.subscribe((e) => { |
| emissions.push(e.type); |
| }); |
| await restoreTestEventDispatcher( |
| host.dispatcher, |
| host.log, |
| testWireScope(SCOPE, 'plan-replay'), |
| records, |
| ); |
| expect(host.agentState.get(planKey)).toEqual({ |
| active: true, |
| id: 'p1', |
| }); |
| expect(emissions).toEqual([]); |
|
|
| const cancelled = buildHost('plan-replay-cancel'); |
| await restoreTestEventDispatcher( |
| cancelled.dispatcher, |
| cancelled.log, |
| testWireScope(SCOPE, 'plan-replay-cancel'), |
| [ |
| { type: 'plan_mode.enter', id: 'p1', planFilePath: '/w/plan/p1.md' }, |
| { type: 'plan_mode.cancel', id: 'p1' }, |
| ], |
| ); |
| expect(cancelled.agentState.get(planKey).active).toBe(false); |
| }); |
|
|
| it('plan.revision persists a flat reference record and advances the per-id counter', async () => { |
| await dispatcher.dispatch(new PlanModeEnter({ agentId: 'test-agent', id: 'p1' })); |
| await dispatcher.dispatch( |
| new PlanRevision({ |
| agentId: 'test-agent', |
| id: 'p1', |
| version: 1, |
| key: 'plan/p1/v1.md', |
| sha256: 'sha-a', |
| bytes: 12, |
| }), |
| ); |
| expect(agentState.get(planKey)).toEqual({ |
| active: true, |
| id: 'p1', |
| revisionCount: { p1: 1 }, |
| }); |
|
|
| await dispatcher.dispatch( |
| new PlanRevision({ |
| agentId: 'test-agent', |
| id: 'p1', |
| version: 2, |
| key: 'plan/p1/v2.md', |
| sha256: 'sha-b', |
| bytes: 20, |
| }), |
| ); |
| expect(agentState.get(planKey).revisionCount).toEqual({ p1: 2 }); |
|
|
| const records = await readRecords(); |
| expect(records.map((record) => record.type)).toEqual([ |
| 'plan_mode.enter', |
| 'plan.revision', |
| 'plan.revision', |
| ]); |
| expect(records[1]).toEqual( |
| expect.objectContaining({ |
| type: 'plan.revision', |
| id: 'p1', |
| version: 1, |
| key: 'plan/p1/v1.md', |
| sha256: 'sha-a', |
| bytes: 12, |
| time: expect.any(Number), |
| }), |
| ); |
| expect(records.every((record) => 'payload' in record === false)).toBe(true); |
| }); |
|
|
| it('keeps the revision counter across the lifecycle and emits the event only live', async () => { |
| const host = buildHost('plan-revision-events'); |
| const emissions: unknown[] = []; |
| host.eventBus.subscribe((e) => { |
| emissions.push(e); |
| }); |
|
|
| await host.dispatcher.dispatch(new PlanModeEnter({ agentId: 'test-agent', id: 'p1' })); |
| await host.dispatcher.dispatch( |
| new PlanRevision({ |
| agentId: 'test-agent', |
| id: 'p1', |
| version: 1, |
| key: 'plan/p1/v1.md', |
| sha256: 'sha-a', |
| bytes: 12, |
| }), |
| ); |
| await host.dispatcher.dispatch(new PlanModeExit({ agentId: 'test-agent' })); |
| expect(host.agentState.get(planKey)).toEqual({ |
| active: false, |
| revisionCount: { p1: 1 }, |
| }); |
|
|
| await host.dispatcher.dispatch(new PlanModeEnter({ agentId: 'test-agent', id: 'p1' })); |
| expect(host.agentState.get(planKey).revisionCount).toEqual({ p1: 1 }); |
|
|
| expect( |
| emissions.filter((e) => (e as { type: string }).type === 'plan.revision'), |
| ).toEqual([ |
| expect.objectContaining({ |
| type: 'plan.revision', |
| id: 'p1', |
| version: 1, |
| key: 'plan/p1/v1.md', |
| sha256: 'sha-a', |
| bytes: 12, |
| }), |
| ]); |
| }); |
|
|
| it('replay restores the revision counter silently', async () => { |
| await dispatcher.dispatch(new PlanModeEnter({ agentId: 'test-agent', id: 'p1' })); |
| await dispatcher.dispatch( |
| new PlanRevision({ |
| agentId: 'test-agent', |
| id: 'p1', |
| version: 1, |
| key: 'plan/p1/v1.md', |
| sha256: 'sha-a', |
| bytes: 12, |
| }), |
| ); |
| await dispatcher.dispatch( |
| new PlanRevision({ |
| agentId: 'test-agent', |
| id: 'p1', |
| version: 2, |
| key: 'plan/p1/v2.md', |
| sha256: 'sha-b', |
| bytes: 20, |
| }), |
| ); |
| const records = await readRecords(); |
|
|
| const host = buildHost('plan-revision-replay'); |
| const emissions: string[] = []; |
| host.eventBus.subscribe((e) => { |
| emissions.push(e.type); |
| }); |
| await restoreTestEventDispatcher( |
| host.dispatcher, |
| host.log, |
| testWireScope(SCOPE, 'plan-revision-replay'), |
| records, |
| ); |
| expect(host.agentState.get(planKey)).toEqual({ |
| active: true, |
| id: 'p1', |
| revisionCount: { p1: 2 }, |
| }); |
| expect(emissions).toEqual([]); |
| }); |
| }); |
|
|
