clawmini 0.0.3 → 0.0.5

package/src/shared/adapters/commands.test.ts

@@ -0,0 +1,155 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleAdapterCommand, type CommandTrpcClient } from './commands.js';
+
+describe('Adapter Commands', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const mockTrpcClient = {
+    getMessages: {
+      query: vi.fn(),
+    },
+  };
+
+  it('should handle /show all', async () => {
+    const config = { filters: {} };
+    const result = await handleAdapterCommand(
+      '/show all',
+      config,
+      mockTrpcClient as unknown as CommandTrpcClient,
+      'chat-1'
+    );
+    expect(result).toEqual({
+      type: 'text',
+      text: 'Configuration updated: Showing all messages.',
+      newConfig: expect.any(Object),
+    });
+    expect((result as Extract<typeof result, { type: 'text' }>).newConfig?.filters).toEqual({
+      subagent: true,
+      command: true,
+      system: true,
+      tool: true,
+      policy: true,
+      subagent_status: true,
+      legacy_log: true,
+    });
+  });
+
+  it('should handle /hide all', async () => {
+    const config = { filters: { tool: true } };
+    const result = await handleAdapterCommand(
+      '/hide all',
+      config,
+      mockTrpcClient as unknown as CommandTrpcClient,
+      'chat-1'
+    );
+    expect(result).toEqual({
+      type: 'text',
+      text: 'Configuration updated: Hidden all overrides (using defaults).',
+      newConfig: expect.any(Object),
+    });
+    expect((result as Extract<typeof result, { type: 'text' }>).newConfig?.filters).toEqual({});
+  });
+
+  it('should handle /show with no arguments', async () => {
+    const config = { filters: {} };
+    const result = await handleAdapterCommand(
+      '/show',
+      config,
+      mockTrpcClient as unknown as CommandTrpcClient,
+      'chat-1'
+    );
+    expect(result?.type).toBe('text');
+    expect((result as { text: string }).text).toContain('Valid options for /show:');
+  });
+
+  it('should handle /hide with no arguments', async () => {
+    const config = { filters: {} };
+    const result = await handleAdapterCommand(
+      '/hide',
+      config,
+      mockTrpcClient as unknown as CommandTrpcClient,
+      'chat-1'
+    );
+    expect(result?.type).toBe('text');
+    expect((result as { text: string }).text).toContain('Valid options for /hide:');
+  });
+
+  it('should handle /show <role>', async () => {
+    const config = { filters: {} };
+    const result = await handleAdapterCommand(
+      '/show tool',
+      config,
+      mockTrpcClient as unknown as CommandTrpcClient,
+      'chat-1'
+    );
+    expect(result).toEqual({
+      type: 'text',
+      text: "Configuration updated: Showing messages for 'tool'.",
+      newConfig: expect.any(Object),
+    });
+    expect((result as Extract<typeof result, { type: 'text' }>).newConfig?.filters).toEqual({
+      tool: true,
+    });
+  });
+
+  it('should handle /hide <role>', async () => {
+    const config = { filters: { command: true } };
+    const result = await handleAdapterCommand(
+      '/hide subagent',
+      config,
+      mockTrpcClient as unknown as CommandTrpcClient,
+      'chat-1'
+    );
+    expect(result).toEqual({
+      type: 'text',
+      text: "Configuration updated: Hiding messages for 'subagent'.",
+      newConfig: expect.any(Object),
+    });
+    expect((result as Extract<typeof result, { type: 'text' }>).newConfig?.filters).toEqual({
+      command: true,
+      subagent: false,
+    });
+  });
+
+  it('should handle /debug <N>', async () => {
+    const config = { filters: {} }; // defaults
+    const mockMessages = [
+      { id: '1', role: 'user', content: 'hello' }, // user without subagentId (displayed by default, excluded)
+      { id: '2', role: 'agent', content: 'hidden agent', subagentId: 'sub1' }, // agent with subagentId (ignored by default)
+      { id: '3', role: 'agent', content: 'visible agent' }, // agent without subagentId (displayed by default)
+      { id: '4', role: 'agent', content: 'hidden agent 2', subagentId: 'sub2' }, // agent with subagentId (ignored by default)
+    ];
+
+    mockTrpcClient.getMessages.query.mockResolvedValueOnce(mockMessages);
+
+    const result = await handleAdapterCommand(
+      '/debug 2',
+      config,
+      mockTrpcClient as unknown as CommandTrpcClient,
+      'chat-1'
+    );
+
+    expect(mockTrpcClient.getMessages.query).toHaveBeenCalledWith({ chatId: 'chat-1', limit: 20 });
+
+    expect(result).toEqual({
+      type: 'debug',
+      messages: [
+        { id: '2', role: 'agent', content: 'hidden agent', subagentId: 'sub1' },
+        { id: '4', role: 'agent', content: 'hidden agent 2', subagentId: 'sub2' },
+      ],
+    });
+  });
+
+  it('should return null for non-commands', async () => {
+    const config = { filters: {} };
+    const result = await handleAdapterCommand(
+      'hello world',
+      config,
+      mockTrpcClient as unknown as CommandTrpcClient,
+      'chat-1'
+    );
+    expect(result).toBeNull();
+  });
+});

package/src/shared/adapters/commands.ts

@@ -0,0 +1,125 @@
+import { shouldDisplayMessage, type FilteringConfig } from './filtering.js';
+import type { ChatMessage } from '../chats.js';
+
+export interface CommandTrpcClient {
+  getMessages: {
+    query: (args: { chatId: string; limit: number }) => Promise<ChatMessage[]>;
+  };
+}
+
+const VALID_ROLES = new Set([
+  'subagent',
+  'command',
+  'system',
+  'tool',
+  'policy',
+  'subagent_status',
+  'legacy_log',
+]);
+
+export type AdapterCommandResult =
+  | { type: 'text'; text: string; newConfig?: FilteringConfig }
+  | { type: 'debug'; messages: ChatMessage[] }
+  | null;
+
+export async function handleAdapterCommand(
+  content: string,
+  config: FilteringConfig,
+  trpcClient: CommandTrpcClient,
+  chatId: string
+): Promise<AdapterCommandResult> {
+  const trimmed = content.trim();
+
+  if (trimmed === '/show all') {
+    const newConfig: FilteringConfig = { filters: { ...config.filters } };
+    for (const role of VALID_ROLES) {
+      newConfig.filters![role] = true;
+    }
+    return { type: 'text', text: 'Configuration updated: Showing all messages.', newConfig };
+  }
+
+  if (trimmed === '/hide all') {
+    return {
+      type: 'text',
+      text: 'Configuration updated: Hidden all overrides (using defaults).',
+      newConfig: { filters: {} },
+    };
+  }
+
+  if (trimmed === '/show' || trimmed === '/hide') {
+    return {
+      type: 'text',
+      text: `Valid options for ${trimmed}: ${Array.from(VALID_ROLES).join(', ')}`,
+    };
+  }
+
+  if (trimmed.startsWith('/show ')) {
+    const role = trimmed.slice(6).trim();
+    if (!VALID_ROLES.has(role)) {
+      return {
+        type: 'text',
+        text: `Error: '${role}' is not a valid message role or special value. Valid options: ${Array.from(VALID_ROLES).join(', ')}`,
+      };
+    }
+    return {
+      type: 'text',
+      text: `Configuration updated: Showing messages for '${role}'.`,
+      newConfig: { filters: { ...config.filters, [role]: true } },
+    };
+  }
+
+  if (trimmed.startsWith('/hide ')) {
+    const role = trimmed.slice(6).trim();
+    if (!VALID_ROLES.has(role)) {
+      return {
+        type: 'text',
+        text: `Error: '${role}' is not a valid message role or special value. Valid options: ${Array.from(VALID_ROLES).join(', ')}`,
+      };
+    }
+    return {
+      type: 'text',
+      text: `Configuration updated: Hiding messages for '${role}'.`,
+      newConfig: { filters: { ...config.filters, [role]: false } },
+    };
+  }
+
+  if (trimmed === '/debug' || trimmed.startsWith('/debug ')) {
+    const match = trimmed.match(/^\/debug\s+(\d+)$/);
+    const limit = match ? parseInt(match[1] as string, 10) : 5;
+
+    // Fetch recent messages
+    // Fetch a larger batch since we need to filter them down
+    const messages: ChatMessage[] = await trpcClient.getMessages.query({
+      chatId,
+      limit: limit * 10,
+    });
+
+    const ignoredMessages: ChatMessage[] = [];
+
+    // Iterating backwards (newest to oldest)
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (!msg) continue;
+
+      // Exclude user messages without subagentIds
+      const isUserWithoutSubagent =
+        (msg.role === 'user' || msg.displayRole === 'user') && !msg.subagentId;
+      if (isUserWithoutSubagent) continue;
+
+      const isDisplayed = shouldDisplayMessage(msg, config);
+      if (!isDisplayed) {
+        ignoredMessages.push(msg);
+        if (ignoredMessages.length >= limit) {
+          break;
+        }
+      }
+    }
+
+    // Reverse back to chronological order
+    ignoredMessages.reverse();
+
+    return { type: 'debug', messages: ignoredMessages };
+  }
+
+  return null;
+}

package/src/shared/adapters/filtering.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest';
+import { shouldDisplayMessage, formatMessage } from './filtering.js';
+import type { ChatMessage } from '../chats.js';
+
+describe('shouldDisplayMessage', () => {
+  const defaultConfig = {};
+
+  it('hides messages with subagentId if subagent is not explicitly true', () => {
+    const msg: ChatMessage = {
+      id: '1',
+      role: 'agent',
+      content: 'hello',
+      subagentId: 'sub1',
+      timestamp: '',
+    };
+    expect(shouldDisplayMessage(msg, defaultConfig)).toBe(false);
+  });
+
+  it('hides standard user messages without subagentId', () => {
+    const msg: ChatMessage = { id: '1', role: 'user', content: 'hello', timestamp: '' };
+    expect(shouldDisplayMessage(msg, defaultConfig)).toBe(false);
+  });
+
+  it('displays standard agent messages without subagentId', () => {
+    const msg: ChatMessage = { id: '1', role: 'agent', content: 'hello', timestamp: '' };
+    expect(shouldDisplayMessage(msg, defaultConfig)).toBe(true);
+  });
+
+  it('hides non-standard messages by default', () => {
+    const msg: ChatMessage = {
+      id: '1',
+      role: 'command',
+      content: 'ls',
+      messageId: '123',
+      command: 'ls',
+      cwd: '.',
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+      timestamp: '',
+    };
+    expect(shouldDisplayMessage(msg, defaultConfig)).toBe(false);
+  });
+
+  it('displays subagent messages if subagent: true', () => {
+    const msg: ChatMessage = {
+      id: '1',
+      role: 'agent',
+      content: 'hello',
+      subagentId: 'sub1',
+      timestamp: '',
+    };
+    expect(shouldDisplayMessage(msg, { filters: { subagent: true } })).toBe(true);
+  });
+
+  it('displays user messages with subagentId if subagent: true', () => {
+    const msg: ChatMessage = {
+      id: '2',
+      role: 'user',
+      content: 'hello subagent',
+      subagentId: 'sub1',
+      timestamp: '',
+    };
+    expect(shouldDisplayMessage(msg, { filters: { subagent: true } })).toBe(true);
+  });
+
+  it('displays specific role if explicitly allowed', () => {
+    const msg: ChatMessage = {
+      id: '1',
+      role: 'command',
+      content: 'ls',
+      messageId: '123',
+      command: 'ls',
+      cwd: '.',
+      stdout: '',
+      stderr: '',
+      exitCode: 0,
+      timestamp: '',
+    };
+    expect(shouldDisplayMessage(msg, { filters: { command: true } })).toBe(true);
+  });
+});
+
+describe('formatMessage', () => {
+  it('returns content as-is for messages without subagentId', () => {
+    const msg: ChatMessage = { id: '1', role: 'agent', content: 'hello world', timestamp: '' };
+    expect(formatMessage(msg)).toBe('hello world');
+  });
+
+  it('prepends [To:<id>] for user messages to subagents', () => {
+    const msg: ChatMessage = {
+      id: '1',
+      role: 'user',
+      content: 'do task',
+      subagentId: 'sub1',
+      timestamp: '',
+    };
+    expect(formatMessage(msg)).toBe('[To:sub1]\ndo task');
+  });
+
+  it('prepends [From:<id>] for agent messages from subagents', () => {
+    const msg: ChatMessage = {
+      id: '1',
+      role: 'agent',
+      content: 'done',
+      subagentId: 'sub1',
+      timestamp: '',
+    };
+    expect(formatMessage(msg)).toBe('[From:sub1]\ndone');
+  });
+});

package/src/shared/adapters/filtering.ts

@@ -0,0 +1,57 @@
+import type { ChatMessage } from '../chats.js';
+
+export interface FilteringConfig {
+  filters?: Record<string, boolean> | undefined;
+}
+
+export function shouldDisplayMessage(message: ChatMessage, config: FilteringConfig): boolean {
+  const overrides = config.filters || {};
+
+  // If the message has a subagentId, return false immediately unless subagent messages are allowed.
+  if (message.subagentId && overrides['subagent'] !== true) {
+    return false;
+  }
+
+  // Then check if it's a standard agent message (via role/displayRole) and always return true if so.
+  const isStandardAgent =
+    message.displayRole === 'agent' ||
+    message.role === 'agent' ||
+    message.role === 'legacy_log' ||
+    (message.role === 'policy' && message.status === 'pending');
+
+  if (isStandardAgent) {
+    return true;
+  }
+
+  // Then check if it's a user message directed to a subagent, if subagent messages are allowed
+  if (
+    message.subagentId &&
+    overrides['subagent'] === true &&
+    (message.role === 'user' || message.displayRole === 'user')
+  ) {
+    return true;
+  }
+
+  // Finally, check if the role is allowed and forward it if so.
+  if (
+    overrides[message.role] === true ||
+    (message.displayRole && overrides[message.displayRole] === true)
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+export function formatMessage(message: ChatMessage): string {
+  if (!message.subagentId) {
+    return message.content;
+  }
+
+  const isToSubagent = message.role === 'user' || message.displayRole === 'user';
+  if (isToSubagent) {
+    return `[To:${message.subagentId}]\n${message.content}`;
+  }
+
+  return `[From:${message.subagentId}]\n${message.content}`;
+}

package/src/shared/adapters/routing.test.ts

@@ -0,0 +1,144 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleRoutingCommand, type RoutingTrpcClient } from './routing.js';
+
+describe('handleRoutingCommand', () => {
+  let mockTrpcClient: RoutingTrpcClient;
+
+  beforeEach(() => {
+    mockTrpcClient = {
+      getChats: { query: vi.fn().mockResolvedValue(['chat-1', 'chat-2']) },
+      getAgents: { query: vi.fn().mockResolvedValue(['agent-1', 'agent-2']) },
+      createChat: { mutate: vi.fn().mockResolvedValue({ success: true, chatId: 'new-chat' }) },
+      sendMessage: { mutate: vi.fn().mockResolvedValue({ success: true }) },
+    };
+  });
+
+  describe('/chat', () => {
+    it('should list available chats if no id provided', async () => {
+      const result = await handleRoutingCommand('/chat', 'ext-1', {}, 'discord', mockTrpcClient);
+      expect(result).toEqual({
+        type: 'reply',
+        text: 'Available chats:\n- chat-1\n- chat-2\n\nPlease specify a valid chat ID: `/chat [chat-id]`',
+      });
+    });
+
+    it('should list available chats if invalid id provided', async () => {
+      const result = await handleRoutingCommand(
+        '/chat chat-3',
+        'ext-1',
+        {},
+        'discord',
+        mockTrpcClient
+      );
+      expect(result).toEqual({
+        type: 'reply',
+        text: 'Available chats:\n- chat-1\n- chat-2\n\nPlease specify a valid chat ID: `/chat [chat-id]`',
+      });
+    });
+
+    it('should return error if chat is already mapped to another channel', async () => {
+      const result = await handleRoutingCommand(
+        '/chat chat-1',
+        'ext-1',
+        { 'ext-2': 'chat-1' },
+        'discord',
+        mockTrpcClient
+      );
+      expect(result).toEqual({
+        type: 'reply',
+        text: 'Error: Chat `chat-1` is already mapped to another channel/space. Strict 1:1 mapping is required.',
+      });
+    });
+
+    it('should map successfully if chat is valid and unmapped', async () => {
+      const result = await handleRoutingCommand(
+        '/chat chat-1',
+        'ext-1',
+        {},
+        'discord',
+        mockTrpcClient
+      );
+      expect(result).toEqual({
+        type: 'mapped',
+        text: 'Successfully mapped this channel/space to chat `chat-1`.',
+        newChatId: 'chat-1',
+      });
+    });
+
+    it('should map successfully if chat is already mapped to the same channel', async () => {
+      const result = await handleRoutingCommand(
+        '/chat chat-1',
+        'ext-1',
+        { 'ext-1': 'chat-1' },
+        'discord',
+        mockTrpcClient
+      );
+      expect(result).toEqual({
+        type: 'mapped',
+        text: 'Successfully mapped this channel/space to chat `chat-1`.',
+        newChatId: 'chat-1',
+      });
+    });
+  });
+
+  describe('/agent', () => {
+    it('should list available agents if no id provided', async () => {
+      const result = await handleRoutingCommand('/agent', 'ext-1', {}, 'discord', mockTrpcClient);
+      expect(result).toEqual({
+        type: 'reply',
+        text: 'Available agents:\n- agent-1\n- agent-2\n\nPlease specify a valid agent ID: `/agent [agent-id]`',
+      });
+    });
+
+    it('should create new chat and map it if agent is valid', async () => {
+      const result = await handleRoutingCommand(
+        '/agent agent-1',
+        'ext-1',
+        {},
+        'discord',
+        mockTrpcClient
+      );
+
+      expect(mockTrpcClient.createChat.mutate).toHaveBeenCalledWith({
+        chatId: 'agent-1-discord',
+        agent: 'agent-1',
+      });
+
+      expect(result).toEqual({
+        type: 'mapped',
+        text: 'Successfully created new chat `agent-1-discord` with agent `agent-1` and mapped it to this channel/space.',
+        newChatId: 'agent-1-discord',
+      });
+    });
+
+    it('should append counter if base chat id exists', async () => {
+      mockTrpcClient.getChats.query = vi
+        .fn()
+        .mockResolvedValue(['agent-1-discord', 'agent-1-discord-1']);
+
+      const result = await handleRoutingCommand(
+        '/agent agent-1',
+        'ext-1',
+        {},
+        'discord',
+        mockTrpcClient
+      );
+
+      expect(mockTrpcClient.createChat.mutate).toHaveBeenCalledWith({
+        chatId: 'agent-1-discord-2',
+        agent: 'agent-1',
+      });
+
+      expect(result).toEqual({
+        type: 'mapped',
+        text: 'Successfully created new chat `agent-1-discord-2` with agent `agent-1` and mapped it to this channel/space.',
+        newChatId: 'agent-1-discord-2',
+      });
+    });
+  });
+
+  it('should return null for non-routing commands', async () => {
+    const result = await handleRoutingCommand('/filter', 'ext-1', {}, 'discord', mockTrpcClient);
+    expect(result).toBeNull();
+  });
+});

package/src/shared/adapters/routing.ts

@@ -0,0 +1,109 @@
+export type RoutingTrpcClient = {
+  getChats: { query: () => Promise<string[]> };
+  getAgents: { query: () => Promise<string[]> };
+  createChat: {
+    mutate: (args: {
+      chatId: string;
+      agent?: string;
+    }) => Promise<{ success: boolean; chatId: string }>;
+  };
+  sendMessage: {
+    mutate: (args: {
+      type: 'send-message';
+      client: 'cli';
+      data: {
+        message: string;
+        chatId?: string;
+        agentId?: string;
+        adapter?: string;
+        noWait?: boolean;
+      };
+    }) => Promise<{ success: boolean }>;
+  };
+};
+
+export type RoutingCommandResult =
+  | { type: 'reply'; text: string }
+  | { type: 'mapped'; text: string; newChatId: string }
+  | null;
+
+export async function handleRoutingCommand(
+  content: string,
+  externalContextId: string,
+  currentChannelChatMap: Record<string, string>,
+  adapterName: string,
+  trpcClient: RoutingTrpcClient
+): Promise<RoutingCommandResult> {
+  const trimmed = content.trim();
+
+  if (trimmed.startsWith('/chat')) {
+    const args = trimmed.split(/\s+/).slice(1);
+    const chatId = args[0];
+
+    const availableChats = await trpcClient.getChats.query();
+
+    if (!chatId || !availableChats.includes(chatId)) {
+      const formattedList =
+        availableChats.length > 0
+          ? availableChats.map((c) => `- ${c}`).join('\n')
+          : 'No chats available.';
+      return {
+        type: 'reply',
+        text: `Available chats:\n${formattedList}\n\nPlease specify a valid chat ID: \`/chat [chat-id]\``,
+      };
+    }
+
+    // Strict 1:1 Mapping Constraint
+    for (const [channelId, mappedId] of Object.entries(currentChannelChatMap)) {
+      if (mappedId === chatId && channelId !== externalContextId) {
+        return {
+          type: 'reply',
+          text: `Error: Chat \`${chatId}\` is already mapped to another channel/space. Strict 1:1 mapping is required.`,
+        };
+      }
+    }
+
+    return {
+      type: 'mapped',
+      text: `Successfully mapped this channel/space to chat \`${chatId}\`.`,
+      newChatId: chatId,
+    };
+  }
+
+  if (trimmed.startsWith('/agent')) {
+    const args = trimmed.split(/\s+/).slice(1);
+    const agentId = args[0];
+
+    const availableAgents = await trpcClient.getAgents.query();
+
+    if (!agentId || !availableAgents.includes(agentId)) {
+      const formattedList =
+        availableAgents.length > 0
+          ? availableAgents.map((a) => `- ${a}`).join('\n')
+          : 'No agents available.';
+      return {
+        type: 'reply',
+        text: `Available agents:\n${formattedList}\n\nPlease specify a valid agent ID: \`/agent [agent-id]\``,
+      };
+    }
+
+    const availableChats = await trpcClient.getChats.query();
+    let newChatId = `${agentId}-${adapterName}`;
+    let counter = 1;
+
+    while (availableChats.includes(newChatId)) {
+      newChatId = `${agentId}-${adapterName}-${counter}`;
+      counter++;
+    }
+
+    await trpcClient.createChat.mutate({ chatId: newChatId, agent: agentId });
+
+    return {
+      type: 'mapped',
+      text: `Successfully created new chat \`${newChatId}\` with agent \`${agentId}\` and mapped it to this channel/space.`,
+      newChatId,
+    };
+  }
+
+  return null;
+}