feat: automate bounded image-sharing conversations

tests/conversation-automation.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ConversationAutomationService } from '../src/services/conversation-automation.js';
+import type { ConversationState } from '../src/services/conversation-state.js';
+
+function harness() {
+  let saved: ConversationState | undefined;
+  const chat = {
+    refreshTopChats: vi.fn().mockResolvedValue(undefined),
+    getCachedConversations: vi.fn().mockResolvedValue([]),
+    sendChatMessage: vi.fn().mockResolvedValue(true),
+  };
+  const ai = { generateMediaAsk: vi.fn().mockResolvedValue('Would you be comfortable sharing a selfie?') };
+  const states = {
+    get: vi.fn(() => saved),
+    save: vi.fn((_id: string, state: ConversationState) => { saved = structuredClone(state); }),
+  };
+  const rateLimiter = {
+    throttle: vi.fn(async (operation: () => Promise<boolean>) => operation()),
+  };
+  const logger = { info: vi.fn() };
+  const service = new ConversationAutomationService(
+    chat as never, ai as never, states as never, rateLimiter as never, logger as never,
+  );
+  return { service, chat, ai, states, getSaved: () => saved };
+}
+
+function incoming(turn: number, text = `reply ${turn}`, media?: Array<{ originalUrl: string; localPath: string; fileName: string }>) {
+  return {
+    username: 'alice', roomName: 'alice', roomId: 'room-alice', url: '/room/room-alice',
+    lastMessageTime: turn, lastMessageSnippet: text, isFromUs: false, unread: true,
+    messages: [
+      { eventId: `out-${turn}`, sender: 'me', text: 'hello', timestamp: turn * 2, isSelf: true },
+      { eventId: `in-${turn}`, sender: 'alice', text, timestamp: turn * 2 + 1, isSelf: false, media },
+    ],
+  };
+}
+
+describe('conversation automation', () => {
+  it('sends once per inbound turn and flags human handoff after the third send', async () => {
+    const { service, chat, getSaved } = harness();
+
+    expect((await service.processConversation(incoming(1)))?.remainingTurns).toBe(2);
+    expect((await service.processConversation(incoming(2)))?.remainingTurns).toBe(1);
+    const third = await service.processConversation(incoming(3));
+
+    expect(third).toMatchObject({ kind: 'human-required', remainingTurns: 0 });
+    expect(chat.sendChatMessage).toHaveBeenCalledTimes(3);
+    expect(getSaved()?.automation).toMatchObject({ turnsUsed: 3, status: 'human-required' });
+    expect(await service.processConversation(incoming(3))).toBeNull();
+  });
+
+  it('stops without sending when the user declines images', async () => {
+    const { service, chat, getSaved } = harness();
+    const result = await service.processConversation(incoming(1, "No thanks, I don't send photos."));
+
+    expect(result?.kind).toBe('boundary');
+    expect(chat.sendChatMessage).not.toHaveBeenCalled();
+    expect(getSaved()?.automation.status).toBe('boundary');
+  });
+
+  it('completes when an inbound image is received', async () => {
+    const { service, chat, getSaved } = harness();
+    const result = await service.processConversation(incoming(1, '[Image]', [{
+      originalUrl: 'mxc://image', localPath: 'image.jpg', fileName: 'image.jpg',
+    }]));
+
+    expect(result?.kind).toBe('image-received');
+    expect(chat.sendChatMessage).not.toHaveBeenCalled();
+    expect(getSaved()?.automation.status).toBe('image-received');
+  });
+
+  it('does not generate or send after a human has overridden the thread', async () => {
+    const { service, chat, ai, states } = harness();
+    const conversation = incoming(1);
+    await service.processConversation(conversation);
+    const state = states.save.mock.calls.at(-1)?.[1] as ConversationState;
+    state.automation.status = 'user-overridden';
+    states.save('room-alice', state);
+
+    const result = await service.processConversation(incoming(2));
+
+    expect(result).toBeNull();
+    expect(chat.sendChatMessage).toHaveBeenCalledTimes(1);
+    expect(ai.generateMediaAsk).toHaveBeenCalledTimes(1);
+  });
+});