Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

6.8 KB
Raw Blame
import { senderFromStorageId } from '@queries/messages/message-sender';
import type { MessageListItem, MessageSender } from '@service-storage/messages';
import { describe, expect, it } from 'vitest';
import { buildChannelMessageListMeta } from '../message-list-meta';

function createMessage(
  id: string,
  createdAt: string,
  senderId = 'user-1',
  sender: MessageSender = senderFromStorageId(senderId)
): MessageListItem {
  return {
    id,
    mentions: [],
    state: {
      root_id: id,
      user_id: 'user-1',
      created_at: '2024-01-01T00:00:00Z',
      updated_at: '2024-01-01T00:00:00Z',
      resolved: false,
    },
    parent: { type: 'channel', id: 'channel-1' },
    content: '',
    created_at: createdAt,
    updated_at: createdAt,
    sender,
    sender_id: senderId,
    attachments: [],
    reactions: [],
    thread: {
      preview: [],
      reply_count: 0,
      latest_reply_at: null,
    },
  };
}

const entries = (messages: MessageListItem[]) =>
  messages.map((message) => ({ type: 'message' as const, message }));

describe('buildChannelMessageListMeta', () => {
  it('keeps a call row apart from the messages around it', () => {
    const first = createMessage('m1', '2026-02-20T09:00:00.000Z');
    const call = createMessage('call', '2026-02-20T09:00:30.000Z');
    const second = createMessage('m2', '2026-02-20T09:01:00.000Z');
    const meta = buildChannelMessageListMeta(
      [
        { type: 'message', message: first },
        { type: 'call', message: call },
        { type: 'message', message: second },
      ],
      () => true,
      true
    );
    expect(meta.call).toMatchObject({
      index: 1,
      isNewMessage: false,
      isGroupedWithPrevious: false,
    });
    expect(meta.m2).toMatchObject({
      previousTopLevelCreatedAt: '2026-02-20T09:00:30.000Z',
      isGroupedWithPrevious: false,
    });
  });

  it('counts activity rows and breaks sender runs and rails at them', () => {
    const first = createMessage('m1', '2026-02-20T09:00:00.000Z');
    const second = createMessage('m2', '2026-02-20T09:01:00.000Z');
    second.thread.reply_count = 1;
    const meta = buildChannelMessageListMeta(
      [
        { type: 'message', message: first },
        {
          type: 'activity',
          activity: { id: 'a1', occurred_at: '2026-02-20T09:00:30.000Z' },
        },
        { type: 'message', message: second },
      ],
      () => false,
      true
    );
    expect(meta['activity:a1']).toMatchObject({
      index: 1,
      previousTopLevelCreatedAt: '2026-02-20T09:00:00.000Z',
      isGroupedWithPrevious: false,
    });
    expect(meta.m2).toMatchObject({
      index: 2,
      previousTopLevelCreatedAt: '2026-02-20T09:00:30.000Z',
      isGroupedWithPrevious: false,
    });
    expect(meta.m1.threadRailBelow).toBeUndefined();
  });

  it('sets list index and previous top-level timestamp in order', () => {
    const messages = [
      createMessage('m1', '2026-02-20T09:00:00.000Z'),
      createMessage('m2', '2026-02-20T10:00:00.000Z'),
      createMessage('m3', '2026-02-21T09:00:00.000Z'),
    ];

    const meta = buildChannelMessageListMeta(
      entries(messages),
      () => false,
      true
    );

    expect(meta.m1).toEqual({
      index: 0,
      isNewMessage: false,
      isFirstNewMessage: false,
      previousTopLevelCreatedAt: undefined,
      isGroupedWithPrevious: false,
      reachedStart: true,
    });
    expect(meta.m2.previousTopLevelCreatedAt).toBe('2026-02-20T09:00:00.000Z');
    expect(meta.m3.previousTopLevelCreatedAt).toBe('2026-02-20T10:00:00.000Z');
  });

  it('marks only the first new message as first new', () => {
    const messages = [
      createMessage('m1', '2026-02-20T09:00:00.000Z'),
      createMessage('m2', '2026-02-20T10:00:00.000Z'),
      createMessage('m3', '2026-02-21T09:00:00.000Z'),
    ];

    const meta = buildChannelMessageListMeta(
      entries(messages),
      (message) => message.id === 'm2' || message.id === 'm3',
      true
    );

    expect(meta.m1.isFirstNewMessage).toBe(false);
    expect(meta.m2.isNewMessage).toBe(true);
    expect(meta.m2.isFirstNewMessage).toBe(true);
    expect(meta.m3.isNewMessage).toBe(true);
    expect(meta.m3.isFirstNewMessage).toBe(false);
  });

  it('derives grouped state from the immediately previous top-level message', () => {
    const messages = [
      createMessage('m1', '2026-02-20T09:00:00.000Z'),
      createMessage('m2', '2026-02-20T09:05:00.000Z'),
      createMessage('m3', '2026-02-20T09:05:01.000Z'),
    ];

    const meta = buildChannelMessageListMeta(
      entries(messages),
      () => false,
      true
    );

    expect(meta.m1.isGroupedWithPrevious).toBe(false);
    expect(meta.m2.isGroupedWithPrevious).toBe(true);
    expect(meta.m3.isGroupedWithPrevious).toBe(true);
  });

  it('marks rows above a grouped thread fork with threadRailBelow', () => {
    const messages = [
      createMessage('m1', '2026-02-20T09:00:00.000Z'),
      createMessage('m2', '2026-02-20T09:01:00.000Z'),
      {
        ...createMessage('m3', '2026-02-20T09:02:00.000Z'),
        thread: {
          preview: [],
          reply_count: 2,
          latest_reply_at: '2026-02-20T09:03:00.000Z',
        },
      },
      createMessage('m4', '2026-02-20T10:30:00.000Z'),
    ];

    const meta = buildChannelMessageListMeta(
      entries(messages),
      () => false,
      true
    );

    // m3 is grouped into the run but owns a thread: the rail passes down
    // through m1 (run header) and m2 to reach it.
    expect(meta.m3.isGroupedWithPrevious).toBe(true);
    expect(meta.m1.threadRailBelow).toBe(true);
    expect(meta.m2.threadRailBelow).toBe(true);
    expect(meta.m3.threadRailBelow).toBeFalsy();
    expect(meta.m4.threadRailBelow).toBeFalsy();
  });

  it('does not group agent messages triggered by different users, despite a shared bot sender_id', () => {
    const botId = 'bot|00000000-0000-0000-0000-000000000000';
    const agentSender = (triggeredBy: string): MessageSender => ({
      type: 'bot',
      id: '00000000-0000-0000-0000-000000000000',
      name: 'Macro',
      triggered_by: triggeredBy,
    });
    const messages = [
      // Two Macro-agent messages with the same bot sender_id but triggered by
      // different users must not merge under one "from" pill.
      createMessage(
        'm1',
        '2026-02-20T09:00:00.000Z',
        botId,
        agentSender('user-a')
      ),
      createMessage(
        'm2',
        '2026-02-20T09:01:00.000Z',
        botId,
        agentSender('user-b')
      ),
      // A third triggered by the same user as m2 groups with it.
      createMessage(
        'm3',
        '2026-02-20T09:02:00.000Z',
        botId,
        agentSender('user-b')
      ),
    ];

    const meta = buildChannelMessageListMeta(
      entries(messages),
      () => false,
      true
    );

    expect(meta.m2.isGroupedWithPrevious).toBe(false);
    expect(meta.m3.isGroupedWithPrevious).toBe(true);
  });
});