kimaki 0.26.0 → 0.28.0

package/src/message-formatting.test.ts

@@ -1,13 +1,13 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { afterEach, describe, test, expect } from 'vitest'
-import { formatBashToolTitle, formatPart, formatTaskToolTitle, formatTodoList, getTextAttachments, serializeEmbeds, serializePoll, serializeMessageSnapshots, TEXT_ATTACHMENT_INLINE_LIMIT_BYTES } from './message-formatting.js'
+import { asDiscordQuote, batchChunksForDiscord, collectSessionChunks, formatBashToolTitle, formatPart, formatTaskToolTitle, formatTodoList, getTextAttachments, planAssistantTurnFlush, serializeEmbeds, serializePoll, serializeMessageSnapshots, sessionPartContent, shouldLeadWithBlankLine, TEXT_ATTACHMENT_INLINE_LIMIT_BYTES } from './message-formatting.js'
 import { getDataDir } from './config.js'
 import type { Collection, Embed, Message, MessageSnapshot, Poll } from 'discord.js'
 import type { Part } from '@opencode-ai/sdk/v2'
 
 describe('formatPart', () => {
-  test('callout text does not get ⬥ prefix', () => {
+  test('callout text is returned without a diamond prefix', () => {
     const part: Part = {
       id: 'test',
       type: 'text',
@@ -16,15 +16,14 @@ describe('formatPart', () => {
       text: `<callout accent="#ef4444">\n## Top priority\n- **Stripe dispute** deadline\n</callout>`,
     }
     expect(formatPart(part)).toMatchInlineSnapshot(`
-      "
-      <callout accent="#ef4444">
+      "<callout accent="#ef4444">
       ## Top priority
       - **Stripe dispute** deadline
       </callout>"
     `)
   })
 
-  test('regular text gets ⬥ prefix', () => {
+  test('regular text has no diamond prefix', () => {
     const part: Part = {
       id: 'test',
       type: 'text',
@@ -32,10 +31,10 @@ describe('formatPart', () => {
       messageID: 'msg_test',
       text: 'hello world',
     }
-    expect(formatPart(part)).toMatchInlineSnapshot(`"⬥ hello world"`)
+    expect(formatPart(part)).toMatchInlineSnapshot(`"hello world"`)
   })
 
-  test('text starting with heading does not get ⬥ prefix', () => {
+  test('heading text has no diamond prefix', () => {
     const part: Part = {
       id: 'test',
       type: 'text',
@@ -44,35 +43,648 @@ describe('formatPart', () => {
       text: '## Summary\nDone.',
     }
     expect(formatPart(part)).toMatchInlineSnapshot(`
-      "
-      ## Summary
+      "## Summary
       Done."
     `)
   })
+
+})
+
+describe('asDiscordQuote', () => {
+  test('prefixes every line', () => {
+    expect(asDiscordQuote('hello\nworld')).toMatchInlineSnapshot(`
+      "> hello
+      > world"
+    `)
+  })
+
+  test('does not double-quote already quoted text', () => {
+    expect(asDiscordQuote('> already quoted')).toMatchInlineSnapshot(`"> already quoted"`)
+  })
+
+  test('prefixes blank lines and later lines, not only the first', () => {
+    expect(asDiscordQuote('I will open that file\n\nthen reply')).toMatchInlineSnapshot(`
+      "> I will open that file
+      > 
+      > then reply"
+    `)
+  })
+})
+
+describe('planAssistantTurnFlush', () => {
+  function text(id: string, body: string, ended = true) {
+    return { id, type: 'text', text: body, time: ended ? { end: 1 } : undefined }
+  }
+  function tool(id: string, name?: string) {
+    return { id, type: 'tool', tool: name }
+  }
+
+  function plan(parts: Array<{ id: string; type: string; text?: string }>, mode: 'progress' | 'interactive' | 'final', throughPartId?: string) {
+    const result = planAssistantTurnFlush({ parts, mode, throughPartId })
+    return { send: result.send, hold: result.hold }
+  }
+
+  test('progress quotes completed short text immediately', () => {
+    expect(
+      plan([text('t1', 'status'), tool('tool1'), text('t2', 'answer')], 'progress'),
+    ).toMatchInlineSnapshot(`
+      {
+        "hold": [],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": true,
+          },
+          {
+            "id": "tool1",
+            "quoteText": false,
+          },
+          {
+            "id": "t2",
+            "quoteText": true,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('progress quotes a lone completed short text', () => {
+    expect(plan([text('t1', 'answer')], 'progress')).toMatchInlineSnapshot(`
+      {
+        "hold": [],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": true,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('progress quotes completed short text before following tools', () => {
+    expect(
+      plan([text('t1', 'status'), tool('tool1')], 'progress'),
+    ).toMatchInlineSnapshot(`
+      {
+        "hold": [],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": true,
+          },
+          {
+            "id": "tool1",
+            "quoteText": false,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('progress quotes each short text that precedes a tool', () => {
+    expect(
+      plan([text('t1', 'status'), text('t2', 'next'), tool('tool1')], 'progress'),
+    ).toMatchInlineSnapshot(`
+      {
+        "hold": [],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": true,
+          },
+          {
+            "id": "t2",
+            "quoteText": true,
+          },
+          {
+            "id": "tool1",
+            "quoteText": false,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('progress holds unfinished last text and following tools', () => {
+    expect(
+      plan([text('t1', 'status', false), tool('tool1')], 'progress'),
+    ).toMatchInlineSnapshot(`
+      {
+        "hold": [
+          {
+            "id": "t1",
+            "quoteText": false,
+          },
+          {
+            "id": "tool1",
+            "quoteText": false,
+          },
+        ],
+        "send": [],
+      }
+    `)
+  })
+
+  test('progress holds unfinished last text until it ends', () => {
+    expect(
+      plan([text('t1', 'first'), text('t2', 'second', false)], 'progress'),
+    ).toMatchInlineSnapshot(`
+      {
+        "hold": [
+          {
+            "id": "t2",
+            "quoteText": false,
+          },
+        ],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": true,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('final quotes earlier text and leaves the last text plain', () => {
+    expect(
+      plan([text('t1', 'status'), tool('tool1'), text('t2', 'done')], 'final'),
+    ).toMatchInlineSnapshot(`
+      {
+        "hold": [],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": true,
+          },
+          {
+            "id": "tool1",
+            "quoteText": false,
+          },
+          {
+            "id": "t2",
+            "quoteText": false,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('final quotes short text before a tool', () => {
+    expect(
+      plan([text('t1', 'status'), tool('tool1')], 'final'),
+    ).toMatchInlineSnapshot(`
+      {
+        "hold": [],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": true,
+          },
+          {
+            "id": "tool1",
+            "quoteText": false,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('interactive without throughPartId sends the last text unquoted', () => {
+    expect(
+      plan([text('t1', 'ask'), tool('question1', 'question')], 'interactive'),
+    ).toMatchInlineSnapshot(`
+      {
+        "hold": [],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": false,
+          },
+          {
+            "id": "question1",
+            "quoteText": false,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('interactive leaves preceding text unquoted and flushes through the interactive tool', () => {
+    expect(
+      plan([text('t1', 'ask'), tool('question1', 'question'), text('t2', 'later')], 'interactive', 'question1'),
+    ).toMatchInlineSnapshot(`
+      {
+        "hold": [
+          {
+            "id": "t2",
+            "quoteText": false,
+          },
+        ],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": false,
+          },
+          {
+            "id": "question1",
+            "quoteText": false,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('progress does not quote earlier text longer than two lines', () => {
+    expect(
+      plan(
+        [
+          text('t1', 'line one\nline two\nline three'),
+          tool('tool1'),
+          text('t2', 'answer'),
+        ],
+        'progress',
+      ),
+    ).toMatchInlineSnapshot(`
+      {
+        "hold": [],
+        "send": [
+          {
+            "id": "t1",
+            "quoteText": false,
+          },
+          {
+            "id": "tool1",
+            "quoteText": false,
+          },
+          {
+            "id": "t2",
+            "quoteText": true,
+          },
+        ],
+      }
+    `)
+  })
+
+  test('progress still quotes two-line earlier text', () => {
+    expect(
+      plan(
+        [text('t1', 'line one\nline two'), tool('tool1'), text('t2', 'answer')],
+        'progress',
+      ).send.find((entry) => entry.id === 't1'),
+    ).toEqual({ id: 't1', quoteText: true })
+  })
+
+  test('progress does not quote earlier text before an interactive tool', () => {
+    expect(
+      plan(
+        [text('t1', 'ask'), tool('question1', 'question'), text('t2', 'later')],
+        'progress',
+      ).send.find((entry) => entry.id === 't1'),
+    ).toEqual({ id: 't1', quoteText: false })
+    expect(
+      plan(
+        [text('t1', 'wait'), tool('sleep1', 'kimaki_sleep'), text('t2', 'later')],
+        'progress',
+      ).send.find((entry) => entry.id === 't1'),
+    ).toEqual({ id: 't1', quoteText: false })
+    expect(
+      plan(
+        [text('t1', 'choose'), tool('buttons1', 'kimaki_action_buttons'), text('t2', 'later')],
+        'progress',
+      ).send.find((entry) => entry.id === 't1'),
+    ).toEqual({ id: 't1', quoteText: false })
+  })
+})
+
+describe('shouldLeadWithBlankLine', () => {
+  test('never leads on the first part', () => {
+    expect(
+      shouldLeadWithBlankLine({ previousKind: undefined, nextKind: 'text' }),
+    ).toBe(false)
+    expect(
+      shouldLeadWithBlankLine({ previousKind: undefined, nextKind: 'tool' }),
+    ).toBe(false)
+  })
+
+  test('leads on both text and tool transitions', () => {
+    expect(
+      shouldLeadWithBlankLine({ previousKind: 'text', nextKind: 'tool' }),
+    ).toBe(true)
+    expect(
+      shouldLeadWithBlankLine({ previousKind: 'tool', nextKind: 'text' }),
+    ).toBe(true)
+    expect(
+      shouldLeadWithBlankLine({ previousKind: 'text', nextKind: 'text' }),
+    ).toBe(false)
+    expect(
+      shouldLeadWithBlankLine({ previousKind: 'tool', nextKind: 'tool' }),
+    ).toBe(false)
+  })
+})
+
+describe('sessionPartContent', () => {
+  test('leaves the first part unchanged', () => {
+    expect(
+      sessionPartContent({ content: 'hello', leadWithBlankLine: false }),
+    ).toBe('hello')
+  })
+
+  test('prepends a newline on text and tool transitions', () => {
+    expect(
+      sessionPartContent({ content: '┣ bash ls', leadWithBlankLine: true }),
+    ).toMatchInlineSnapshot(`
+      "
+      ┣ bash ls"
+    `)
+    expect(
+      sessionPartContent({ content: 'done', leadWithBlankLine: true }),
+    ).toMatchInlineSnapshot(`
+      "
+      done"
+    `)
+  })
+})
+
+describe('collectSessionChunks', () => {
+  function textPart({
+    id,
+    text,
+    messageID,
+  }: {
+    id: string
+    text: string
+    messageID: string
+  }): Part {
+    return {
+      id,
+      type: 'text',
+      sessionID: 'ses_test',
+      messageID,
+      text,
+    }
+  }
+
+  test('quotes short text throughout a turn', () => {
+    const { chunks } = collectSessionChunks({
+      messages: [
+        {
+          info: { role: 'assistant', id: 'msg_1', parentID: 'msg_user' },
+          parts: [textPart({ id: 't1', text: 'I will read it', messageID: 'msg_1' })],
+        },
+        {
+          info: { role: 'assistant', id: 'msg_2', parentID: 'msg_user' },
+          parts: [textPart({ id: 't2', text: 'done', messageID: 'msg_2' })],
+        },
+      ],
+    })
+    expect(chunks.map((chunk) => chunk.content)).toMatchInlineSnapshot(`
+      [
+        "> I will read it",
+        "> done",
+      ]
+    `)
+  })
+
+  test('quotes short text before a tool', () => {
+    const { chunks } = collectSessionChunks({
+      messages: [
+        {
+          info: { role: 'assistant', id: 'msg_1', parentID: 'msg_user' },
+          parts: [
+            textPart({ id: 't1', text: 'I will read it', messageID: 'msg_1' }),
+            {
+              id: 'tool1',
+              type: 'tool',
+              sessionID: 'ses_test',
+              messageID: 'msg_1',
+              tool: 'read',
+              callID: 'call_tool1',
+              state: { status: 'completed', input: {}, output: '', title: '', metadata: {}, time: { start: 0, end: 0 } },
+            },
+          ],
+        },
+      ],
+    })
+    expect(chunks.map((chunk) => chunk.content)).toEqual([
+      '> I will read it',
+      '┣ read',
+    ])
+  })
+
+  test('does not quote earlier text longer than two lines', () => {
+    const { chunks } = collectSessionChunks({
+      messages: [
+        {
+          info: { role: 'assistant', id: 'msg_1', parentID: 'msg_user' },
+          parts: [
+            textPart({
+              id: 't1',
+              text: 'line one\nline two\nline three',
+              messageID: 'msg_1',
+            }),
+          ],
+        },
+        {
+          info: { role: 'assistant', id: 'msg_2', parentID: 'msg_user' },
+          parts: [textPart({ id: 't2', text: 'done', messageID: 'msg_2' })],
+        },
+      ],
+    })
+    expect(chunks.map((chunk) => chunk.content)).toEqual([
+      'line one\nline two\nline three',
+      '> done',
+    ])
+  })
+
+  test('does not quote text flushed before a question tool', () => {
+    const { chunks } = collectSessionChunks({
+      messages: [
+        {
+          info: { role: 'assistant', id: 'msg_1', parentID: 'msg_user' },
+          parts: [
+            textPart({ id: 't1', text: 'Pick one', messageID: 'msg_1' }),
+            {
+              id: 'q1',
+              type: 'tool',
+              sessionID: 'ses_test',
+              messageID: 'msg_1',
+              tool: 'question',
+              callID: 'call_q1',
+              state: { status: 'completed', input: {}, output: '', title: '', metadata: {}, time: { start: 0, end: 0 } },
+            },
+            textPart({ id: 't2', text: 'thanks', messageID: 'msg_1' }),
+          ],
+        },
+      ],
+    })
+    expect(chunks.map((chunk) => chunk.content)).toEqual(['Pick one', '> thanks'])
+  })
+
+  test('quotes within each user turn separately', () => {
+    const { chunks } = collectSessionChunks({
+      messages: [
+        {
+          info: { role: 'assistant', id: 'msg_1', parentID: 'msg_user_1' },
+          parts: [textPart({ id: 't1', text: 'first turn', messageID: 'msg_1' })],
+        },
+        {
+          info: { role: 'user', id: 'msg_user_2' },
+          parts: [],
+        },
+        {
+          info: { role: 'assistant', id: 'msg_2', parentID: 'msg_user_2' },
+          parts: [textPart({ id: 't2', text: 'looking', messageID: 'msg_2' })],
+        },
+        {
+          info: { role: 'assistant', id: 'msg_3', parentID: 'msg_user_2' },
+          parts: [textPart({ id: 't3', text: 'second turn done', messageID: 'msg_3' })],
+        },
+      ],
+    })
+    expect(chunks.map((chunk) => chunk.content)).toMatchInlineSnapshot(`
+      [
+        "> first turn",
+        "> looking",
+        "> second turn done",
+      ]
+    `)
+  })
+})
+
+describe('batchChunksForDiscord', () => {
+  test('does not merge text chunks with tool chunks', () => {
+    expect(
+      batchChunksForDiscord([
+        { partIds: ['t1'], content: 'hello', kind: 'text' },
+        { partIds: ['b1'], content: '┣ bash ls', kind: 'tool' },
+        { partIds: ['t2'], content: 'done', kind: 'text' },
+      ]),
+    ).toMatchInlineSnapshot(`
+      [
+        {
+          "content": "hello",
+          "kind": "text",
+          "partIds": [
+            "t1",
+          ],
+        },
+        {
+          "content": "┣ bash ls",
+          "kind": "tool",
+          "partIds": [
+            "b1",
+          ],
+        },
+        {
+          "content": "done",
+          "kind": "text",
+          "partIds": [
+            "t2",
+          ],
+        },
+      ]
+    `)
+  })
 })
 
 describe('formatTaskToolTitle', () => {
-  test('uses the completed task title when OpenAI omits the description', () => {
-    const part: Extract<Part, { type: 'tool' }> = {
+  function taskPart({
+    status,
+    input = {},
+    title = '',
+    sessionId,
+  }: {
+    status: 'running' | 'completed'
+    input?: { description?: string; subagent_type?: string }
+    title?: string
+    sessionId?: string
+  }): Extract<Part, { type: 'tool' }> {
+    const base = {
       id: 'prt_task',
-      type: 'tool',
+      type: 'tool' as const,
       tool: 'task',
       callID: 'call_task',
       sessionID: 'ses_parent',
       messageID: 'msg_assistant',
+    }
+    if (status === 'completed') {
+      return {
+        ...base,
+        state: {
+          status,
+          input,
+          output: '',
+          title,
+          metadata: sessionId ? { sessionId } : {},
+          time: { start: 1, end: 2 },
+        },
+      }
+    }
+    return {
+      ...base,
       state: {
-        status: 'completed',
-        input: { subagent_type: 'general' },
-        output: '',
-        title: 'Classify pending changes',
-        metadata: { sessionId: 'ses_child' },
-        time: { start: 1, end: 2 },
+        status,
+        input,
+        title,
+        metadata: sessionId ? { sessionId } : {},
+        time: { start: 1 },
       },
     }
+  }
 
-    expect(formatTaskToolTitle(part)).toMatchInlineSnapshot(
-      `"┣ general **Classify pending changes**"`,
-    )
+  test('uses the running task title when OpenAI omits the description', () => {
+    expect(
+      formatTaskToolTitle(
+        taskPart({
+          status: 'running',
+          input: { subagent_type: 'general' },
+          title: 'Classify pending changes',
+          sessionId: 'ses_child',
+        }),
+      ),
+    ).toMatchInlineSnapshot(`"┣ general **Classify pending changes**"`)
+  })
+
+  test('prefers input description on running parts', () => {
+    expect(
+      formatTaskToolTitle(
+        taskPart({
+          status: 'running',
+          input: { description: 'inspect repo', subagent_type: 'explore' },
+          title: 'ignored title',
+          sessionId: 'ses_child',
+        }),
+      ),
+    ).toMatchInlineSnapshot(`"┣ explore **inspect repo**"`)
+  })
+
+  test('does not format completed parts so Discord does not post the line at the end', () => {
+    expect(
+      formatTaskToolTitle(
+        taskPart({
+          status: 'completed',
+          input: { subagent_type: 'general' },
+          title: 'Classify pending changes',
+          sessionId: 'ses_child',
+        }),
+      ),
+    ).toBe('')
+  })
+
+  test('shows queued task calls before the child session exists', () => {
+    expect(
+      formatTaskToolTitle(
+        taskPart({
+          status: 'running',
+          input: {
+            description: 'audit customer pages',
+            subagent_type: 'general',
+          },
+        }),
+      ),
+    ).toMatchInlineSnapshot(`"┣ general **audit customer pages**"`)
   })
 })
 
@@ -103,6 +715,41 @@ describe('formatBashToolTitle', () => {
     ).toMatchInlineSnapshot(`" _Print greeting_"`)
   })
 
+  test('50-char single-line command is shown in full', () => {
+    const command = 'a'.repeat(50)
+    expect(formatBashToolTitle({ command, description: 'Ignored' })).toBe(
+      ` _${command}_`,
+    )
+  })
+
+  test('51-char single-line command uses description', () => {
+    expect(
+      formatBashToolTitle({
+        command: 'a'.repeat(51),
+        description: 'Run long command',
+      }),
+    ).toMatchInlineSnapshot(`" _Run long command_"`)
+  })
+
+  test('51-char single-line command uses summary when description is missing', () => {
+    expect(
+      formatBashToolTitle({
+        command: 'a'.repeat(51),
+        summary: 'Install packages',
+      }),
+    ).toMatchInlineSnapshot(`" _Install packages_"`)
+  })
+
+  test('description wins over summary for long commands', () => {
+    expect(
+      formatBashToolTitle({
+        command: 'a'.repeat(51),
+        description: 'Preferred label',
+        summary: 'Ignored label',
+      }),
+    ).toMatchInlineSnapshot(`" _Preferred label_"`)
+  })
+
   test('stateTitle used as last resort', () => {
     expect(
       formatBashToolTitle({ command: '', stateTitle: 'Running tests' }),
@@ -136,7 +783,7 @@ describe('formatBashToolTitle', () => {
 })
 
 describe('formatTodoList', () => {
-  test('formats active todo with monospace numbers', () => {
+  test('formats active todo with number, dot, and two spaces', () => {
     const part: Part = {
       id: 'test',
       type: 'tool',
@@ -160,7 +807,7 @@ describe('formatTodoList', () => {
       },
     }
 
-    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⒉ **second task**"`)
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"2.  **second task**"`)
   })
 
   test('formats double digit todo numbers', () => {
@@ -186,7 +833,7 @@ describe('formatTodoList', () => {
       },
     }
 
-    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⒓ **task 12**"`)
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"12.  **task 12**"`)
   })
 
   test('lowercases first letter of content', () => {
@@ -209,7 +856,7 @@ describe('formatTodoList', () => {
       },
     }
 
-    expect(formatTodoList(part)).toMatchInlineSnapshot(`"⒈ **fix the bug**"`)
+    expect(formatTodoList(part)).toMatchInlineSnapshot(`"1.  **fix the bug**"`)
   })
 })