kimaki 0.4.9 → 0.4.12

package/dist/discordBot.js

@@ -22,6 +22,50 @@ import { isAbortError } from './utils.js';
 import { setGlobalDispatcher, Agent } from 'undici';
 // disables the automatic 5 minutes abort after no body
 setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }));
+export const OPENCODE_SYSTEM_MESSAGE = `
+The user is reading your messages from inside Discord, via kimaki.xyz
+
+After each message, if you implemented changes, you can show the user a diff via an url running the command, to show the changes in working directory:
+
+bunx critique web
+
+you can also show latest commit changes using
+
+bunx critique web HEAD~1
+
+do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
+
+## markdown
+
+discord does support basic markdown features like code blocks, code blocks languages, inline code, bold, italic, quotes, etc.
+
+the max heading level is 3, so do not use ####
+
+headings are discouraged anyway. instead try to use bold text for titles which renders more nicely in Discord
+
+## tables
+
+discord does NOT support markdown gfm tables.
+
+so instead of using full markdown tables ALWAYS show code snippets with space aligned cells:
+
+\`\`\`
+Item        Qty   Price
+----------  ---   -----
+Apples      10    $5
+Oranges     3     $2
+\`\`\`
+
+Using code blocks will make the content use monospaced font so that space will be aligned correctly
+
+IMPORTANT: add enough space characters to align the table! otherwise the content will not look good and will be difficult to understand for the user
+
+code blocks for tables and diagrams MUST have Max length of 85 characters. otherwise the content will wrap
+
+## diagrams
+
+you can create diagrams wrapping them in code blocks too.
+`;
 const discordLogger = createLogger('DISCORD');
 const voiceLogger = createLogger('VOICE');
 const opencodeLogger = createLogger('OPENCODE');
@@ -451,60 +495,20 @@ async function getOpenPort() {
 async function sendThreadMessage(thread, content) {
     const MAX_LENGTH = 2000;
     content = escapeBackticksInCodeBlocks(content);
-    // Simple case: content fits in one message
-    if (content.length <= MAX_LENGTH) {
-        return await thread.send(content);
+    const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH });
+    if (chunks.length > 1) {
+        discordLogger.log(`MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`);
     }
-    // Use marked's lexer to tokenize markdown content
-    const lexer = new Lexer();
-    const tokens = lexer.lex(content);
-    const chunks = [];
-    let currentChunk = '';
-    // Process each token and add to chunks
-    for (const token of tokens) {
-        const tokenText = token.raw || '';
-        // If adding this token would exceed limit and we have content, flush current chunk
-        if (currentChunk && currentChunk.length + tokenText.length > MAX_LENGTH) {
-            chunks.push(currentChunk);
-            currentChunk = '';
-        }
-        // If this single token is longer than MAX_LENGTH, split it
-        if (tokenText.length > MAX_LENGTH) {
-            if (currentChunk) {
-                chunks.push(currentChunk);
-                currentChunk = '';
-            }
-            let remainingText = tokenText;
-            while (remainingText.length > MAX_LENGTH) {
-                // Try to split at a newline if possible
-                let splitIndex = MAX_LENGTH;
-                const newlineIndex = remainingText.lastIndexOf('\n', MAX_LENGTH - 1);
-                if (newlineIndex > MAX_LENGTH * 0.7) {
-                    splitIndex = newlineIndex + 1;
-                }
-                chunks.push(remainingText.slice(0, splitIndex));
-                remainingText = remainingText.slice(splitIndex);
-            }
-            currentChunk = remainingText;
-        }
-        else {
-            currentChunk += tokenText;
-        }
-    }
-    // Add any remaining content
-    if (currentChunk) {
-        chunks.push(currentChunk);
-    }
-    // Send all chunks
-    discordLogger.log(`MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`);
     let firstMessage;
     for (let i = 0; i < chunks.length; i++) {
         const chunk = chunks[i];
-        if (!chunk)
+        if (!chunk) {
             continue;
+        }
         const message = await thread.send(chunk);
-        if (i === 0)
+        if (i === 0) {
             firstMessage = message;
+        }
     }
     return firstMessage;
 }
@@ -621,6 +625,77 @@ export function escapeBackticksInCodeBlocks(markdown) {
     }
     return result;
 }
+export function splitMarkdownForDiscord({ content, maxLength, }) {
+    if (content.length <= maxLength) {
+        return [content];
+    }
+    const lexer = new Lexer();
+    const tokens = lexer.lex(content);
+    const lines = [];
+    for (const token of tokens) {
+        if (token.type === 'code') {
+            const lang = token.lang || '';
+            lines.push({ text: '```' + lang + '\n', inCodeBlock: false, lang, isOpeningFence: true, isClosingFence: false });
+            const codeLines = token.text.split('\n');
+            for (const codeLine of codeLines) {
+                lines.push({ text: codeLine + '\n', inCodeBlock: true, lang, isOpeningFence: false, isClosingFence: false });
+            }
+            lines.push({ text: '```\n', inCodeBlock: false, lang: '', isOpeningFence: false, isClosingFence: true });
+        }
+        else {
+            const rawLines = token.raw.split('\n');
+            for (let i = 0; i < rawLines.length; i++) {
+                const isLast = i === rawLines.length - 1;
+                const text = isLast ? rawLines[i] : rawLines[i] + '\n';
+                if (text) {
+                    lines.push({ text, inCodeBlock: false, lang: '', isOpeningFence: false, isClosingFence: false });
+                }
+            }
+        }
+    }
+    const chunks = [];
+    let currentChunk = '';
+    let currentLang = null;
+    for (const line of lines) {
+        const wouldExceed = currentChunk.length + line.text.length > maxLength;
+        if (wouldExceed && currentChunk) {
+            if (currentLang !== null) {
+                currentChunk += '```\n';
+            }
+            chunks.push(currentChunk);
+            if (line.isClosingFence && currentLang !== null) {
+                currentChunk = '';
+                currentLang = null;
+                continue;
+            }
+            if (line.inCodeBlock || line.isOpeningFence) {
+                const lang = line.lang;
+                currentChunk = '```' + lang + '\n';
+                if (!line.isOpeningFence) {
+                    currentChunk += line.text;
+                }
+                currentLang = lang;
+            }
+            else {
+                currentChunk = line.text;
+                currentLang = null;
+            }
+        }
+        else {
+            currentChunk += line.text;
+            if (line.inCodeBlock || line.isOpeningFence) {
+                currentLang = line.lang;
+            }
+            else if (line.isClosingFence) {
+                currentLang = null;
+            }
+        }
+    }
+    if (currentChunk) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
 /**
  * Escape Discord formatting characters to prevent breaking code blocks and inline code
  */
@@ -1265,6 +1340,7 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
             path: { id: session.id },
             body: {
                 parts,
+                system: OPENCODE_SYSTEM_MESSAGE,
             },
             signal: abortController.signal,
         });

package/dist/escape-backticks.test.js

@@ -1,6 +1,6 @@
 import { test, expect } from 'vitest';
 import { Lexer } from 'marked';
-import { escapeBackticksInCodeBlocks } from './discordBot.js';
+import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord } from './discordBot.js';
 test('escapes single backticks in code blocks', () => {
     const input = '```js\nconst x = `hello`\n```';
     const result = escapeBackticksInCodeBlocks(input);
@@ -123,3 +123,288 @@ const x = \\\`hello\\\`
 "
 `);
 });
+test('splitMarkdownForDiscord returns single chunk for short content', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Hello world',
+        maxLength: 100,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Hello world",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord splits at line boundaries', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Line 1\nLine 2\nLine 3\nLine 4',
+        maxLength: 15,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Line 1
+    Line 2
+    ",
+      "Line 3
+    Line 4",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord preserves code blocks when not split', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nconst x = 1\n```',
+        maxLength: 100,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    const x = 1
+    \`\`\`",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord adds closing and opening fences when splitting code block', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nline1\nline2\nline3\nline4\n```',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    line1
+    line2
+    \`\`\`
+    ",
+      "\`\`\`js
+    line3
+    line4
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block with language', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```typescript\nconst a = 1\nconst b = 2\n```',
+        maxLength: 30,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`typescript
+    const a = 1
+    \`\`\`
+    ",
+      "\`\`\`typescript
+    const b = 2
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles mixed content with code blocks', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Text before\n```js\ncode\n```\nText after',
+        maxLength: 25,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Text before
+    \`\`\`js
+    code
+    \`\`\`
+    ",
+      "Text after",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block without language', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```\nline1\nline2\n```',
+        maxLength: 12,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`
+    line1
+    \`\`\`
+    ",
+      "\`\`\`
+    line2
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles multiple consecutive code blocks', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nfoo\n```\n```py\nbar\n```',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    foo
+    \`\`\`
+    \`\`\`py
+    \`\`\`
+    ",
+      "\`\`\`py
+    bar
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles empty code block', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'before\n```\n```\nafter',
+        maxLength: 50,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "before
+    \`\`\`
+    \`\`\`
+    after",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles content exactly at maxLength', () => {
+    const result = splitMarkdownForDiscord({
+        content: '12345678901234567890',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "12345678901234567890",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block only', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```ts\nconst x = 1\n```',
+        maxLength: 15,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`ts
+    \`\`\`
+    ",
+      "\`\`\`ts
+    const x = 1
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles code block at start with text after', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\ncode\n```\nSome text after',
+        maxLength: 20,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    code
+    \`\`\`
+    ",
+      "Some text after",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles text before code block at end', () => {
+    const result = splitMarkdownForDiscord({
+        content: 'Some text before\n```js\ncode\n```',
+        maxLength: 25,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Some text before
+    \`\`\`js
+    \`\`\`
+    ",
+      "\`\`\`js
+    code
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles very long line inside code block', () => {
+    const result = splitMarkdownForDiscord({
+        content: '```js\nshort\nveryverylonglinethatexceedsmaxlength\nshort\n```',
+        maxLength: 25,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    short
+    \`\`\`
+    ",
+      "\`\`\`js
+    veryverylonglinethatexceedsmaxlength
+    \`\`\`
+    ",
+      "\`\`\`js
+    short
+    \`\`\`
+    ",
+    ]
+  `);
+});
+test('splitMarkdownForDiscord handles realistic long markdown with code block', () => {
+    const content = `Here is some explanation text before the code.
+
+\`\`\`typescript
+export function calculateTotal(items: Item[]): number {
+  let total = 0
+  for (const item of items) {
+    total += item.price * item.quantity
+  }
+  return total
+}
+
+export function formatCurrency(amount: number): string {
+  return new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+  }).format(amount)
+}
+\`\`\`
+
+And here is some text after the code block.`;
+    const result = splitMarkdownForDiscord({
+        content,
+        maxLength: 200,
+    });
+    expect(result).toMatchInlineSnapshot(`
+    [
+      "Here is some explanation text before the code.
+
+    \`\`\`typescript
+    export function calculateTotal(items: Item[]): number {
+      let total = 0
+      for (const item of items) {
+    \`\`\`
+    ",
+      "\`\`\`typescript
+        total += item.price * item.quantity
+      }
+      return total
+    }
+
+    export function formatCurrency(amount: number): string {
+      return new Intl.NumberFormat('en-US', {
+        style: 'currency',
+    \`\`\`
+    ",
+      "\`\`\`typescript
+        currency: 'USD',
+      }).format(amount)
+    }
+    \`\`\`
+
+
+    And here is some text after the code block.",
+    ]
+  `);
+});

package/dist/opencode-plugin.js

@@ -25,6 +25,9 @@ export const KimakiDiscordPlugin = async ({ client, $, directory, }) => {
                 });
                 return;
             }
+            await client.tui.showToast({
+                body: { message: 'Creating Discord thread...', variant: 'info' },
+            });
             try {
                 const result = await $ `npx -y kimaki send-to-discord ${sessionID} -d ${directory}`.text();
                 const urlMatch = result.match(/https:\/\/discord\.com\/channels\/\S+/);

package/dist/tools.js

@@ -8,7 +8,7 @@ const toolsLogger = createLogger('TOOLS');
 import { formatDistanceToNow } from 'date-fns';
 import { ShareMarkdown } from './markdown.js';
 import pc from 'picocolors';
-import { initializeOpencodeForDirectory } from './discordBot.js';
+import { initializeOpencodeForDirectory, OPENCODE_SYSTEM_MESSAGE, } from './discordBot.js';
 export async function getTools({ onMessageCompleted, directory, }) {
     const getClient = await initializeOpencodeForDirectory(directory);
     const client = getClient();
@@ -48,6 +48,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     body: {
                         parts: [{ type: 'text', text: message }],
                         model: sessionModel,
+                        system: OPENCODE_SYSTEM_MESSAGE,
                     },
                 })
                     .then(async (response) => {
@@ -114,7 +115,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         path: { id: session.data.id },
                         body: {
                             parts: [{ type: 'text', text: message }],
-                            // model,
+                            system: OPENCODE_SYSTEM_MESSAGE,
                         },
                     })
                         .then(async (response) => {

package/dist/voice.js

@@ -28,7 +28,17 @@ export async function transcribeAudio({ audio, prompt, language, temperature, ge
             throw new Error('Invalid audio format');
         }
         // Build the transcription prompt
-        let transcriptionPrompt = `Please transcribe this audio file accurately. Here is some relevant information and filenames that may be present in the audio:\n<context>\n${prompt}\n</context>\n`;
+        let transcriptionPrompt = `Transcribe this audio accurately. The transcription will be sent to a coding agent (like Claude Code) to execute programming tasks.
+
+Assume the speaker is using technical and programming terminology: file paths, function names, CLI commands, package names, API names, programming concepts, etc. Prioritize technical accuracy over literal transcription - if a word sounds like a common programming term, prefer that interpretation.
+
+If the spoken message is unclear or ambiguous, rephrase it to better convey the intended meaning for a coding agent. The goal is effective communication of the user's programming intent, not a word-for-word transcription.
+
+Here are relevant filenames and context that may appear in the audio:
+<context>
+${prompt}
+</context>
+`;
         if (language) {
             transcriptionPrompt += `\nThe audio is in ${language}.`;
         }

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.9",
+  "version": "0.4.12",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",

package/src/discordBot.ts

@@ -54,6 +54,51 @@ import { setGlobalDispatcher, Agent } from 'undici'
 // disables the automatic 5 minutes abort after no body
 setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }))
 
+export const OPENCODE_SYSTEM_MESSAGE = `
+The user is reading your messages from inside Discord, via kimaki.xyz
+
+After each message, if you implemented changes, you can show the user a diff via an url running the command, to show the changes in working directory:
+
+bunx critique web
+
+you can also show latest commit changes using
+
+bunx critique web HEAD~1
+
+do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
+
+## markdown
+
+discord does support basic markdown features like code blocks, code blocks languages, inline code, bold, italic, quotes, etc.
+
+the max heading level is 3, so do not use ####
+
+headings are discouraged anyway. instead try to use bold text for titles which renders more nicely in Discord
+
+## tables
+
+discord does NOT support markdown gfm tables.
+
+so instead of using full markdown tables ALWAYS show code snippets with space aligned cells:
+
+\`\`\`
+Item        Qty   Price
+----------  ---   -----
+Apples      10    $5
+Oranges     3     $2
+\`\`\`
+
+Using code blocks will make the content use monospaced font so that space will be aligned correctly
+
+IMPORTANT: add enough space characters to align the table! otherwise the content will not look good and will be difficult to understand for the user
+
+code blocks for tables and diagrams MUST have Max length of 85 characters. otherwise the content will wrap
+
+## diagrams
+
+you can create diagrams wrapping them in code blocks too.
+`
+
 const discordLogger = createLogger('DISCORD')
 const voiceLogger = createLogger('VOICE')
 const opencodeLogger = createLogger('OPENCODE')
@@ -629,69 +674,24 @@ async function sendThreadMessage(
 
   content = escapeBackticksInCodeBlocks(content)
 
-  // Simple case: content fits in one message
-  if (content.length <= MAX_LENGTH) {
-    return await thread.send(content)
-  }
-
-  // Use marked's lexer to tokenize markdown content
-  const lexer = new Lexer()
-  const tokens = lexer.lex(content)
+  const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH })
 
-  const chunks: string[] = []
-  let currentChunk = ''
-
-  // Process each token and add to chunks
-  for (const token of tokens) {
-    const tokenText = token.raw || ''
-
-    // If adding this token would exceed limit and we have content, flush current chunk
-    if (currentChunk && currentChunk.length + tokenText.length > MAX_LENGTH) {
-      chunks.push(currentChunk)
-      currentChunk = ''
-    }
-
-    // If this single token is longer than MAX_LENGTH, split it
-    if (tokenText.length > MAX_LENGTH) {
-      if (currentChunk) {
-        chunks.push(currentChunk)
-        currentChunk = ''
-      }
-
-      let remainingText = tokenText
-      while (remainingText.length > MAX_LENGTH) {
-        // Try to split at a newline if possible
-        let splitIndex = MAX_LENGTH
-        const newlineIndex = remainingText.lastIndexOf('\n', MAX_LENGTH - 1)
-        if (newlineIndex > MAX_LENGTH * 0.7) {
-          splitIndex = newlineIndex + 1
-        }
-
-        chunks.push(remainingText.slice(0, splitIndex))
-        remainingText = remainingText.slice(splitIndex)
-      }
-      currentChunk = remainingText
-    } else {
-      currentChunk += tokenText
-    }
-  }
-
-  // Add any remaining content
-  if (currentChunk) {
-    chunks.push(currentChunk)
+  if (chunks.length > 1) {
+    discordLogger.log(
+      `MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`,
+    )
   }
 
-  // Send all chunks
-  discordLogger.log(
-    `MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`,
-  )
-
   let firstMessage: Message | undefined
   for (let i = 0; i < chunks.length; i++) {
     const chunk = chunks[i]
-    if (!chunk) continue
+    if (!chunk) {
+      continue
+    }
     const message = await thread.send(chunk)
-    if (i === 0) firstMessage = message
+    if (i === 0) {
+      firstMessage = message
+    }
   }
 
   return firstMessage!
@@ -852,6 +852,97 @@ export function escapeBackticksInCodeBlocks(markdown: string): string {
   return result
 }
 
+type LineInfo = {
+  text: string
+  inCodeBlock: boolean
+  lang: string
+  isOpeningFence: boolean
+  isClosingFence: boolean
+}
+
+export function splitMarkdownForDiscord({
+  content,
+  maxLength,
+}: {
+  content: string
+  maxLength: number
+}): string[] {
+  if (content.length <= maxLength) {
+    return [content]
+  }
+
+  const lexer = new Lexer()
+  const tokens = lexer.lex(content)
+
+  const lines: LineInfo[] = []
+  for (const token of tokens) {
+    if (token.type === 'code') {
+      const lang = token.lang || ''
+      lines.push({ text: '```' + lang + '\n', inCodeBlock: false, lang, isOpeningFence: true, isClosingFence: false })
+      const codeLines = token.text.split('\n')
+      for (const codeLine of codeLines) {
+        lines.push({ text: codeLine + '\n', inCodeBlock: true, lang, isOpeningFence: false, isClosingFence: false })
+      }
+      lines.push({ text: '```\n', inCodeBlock: false, lang: '', isOpeningFence: false, isClosingFence: true })
+    } else {
+      const rawLines = token.raw.split('\n')
+      for (let i = 0; i < rawLines.length; i++) {
+        const isLast = i === rawLines.length - 1
+        const text = isLast ? rawLines[i]! : rawLines[i]! + '\n'
+        if (text) {
+          lines.push({ text, inCodeBlock: false, lang: '', isOpeningFence: false, isClosingFence: false })
+        }
+      }
+    }
+  }
+
+  const chunks: string[] = []
+  let currentChunk = ''
+  let currentLang: string | null = null
+
+  for (const line of lines) {
+    const wouldExceed = currentChunk.length + line.text.length > maxLength
+
+    if (wouldExceed && currentChunk) {
+      if (currentLang !== null) {
+        currentChunk += '```\n'
+      }
+      chunks.push(currentChunk)
+
+      if (line.isClosingFence && currentLang !== null) {
+        currentChunk = ''
+        currentLang = null
+        continue
+      }
+
+      if (line.inCodeBlock || line.isOpeningFence) {
+        const lang = line.lang
+        currentChunk = '```' + lang + '\n'
+        if (!line.isOpeningFence) {
+          currentChunk += line.text
+        }
+        currentLang = lang
+      } else {
+        currentChunk = line.text
+        currentLang = null
+      }
+    } else {
+      currentChunk += line.text
+      if (line.inCodeBlock || line.isOpeningFence) {
+        currentLang = line.lang
+      } else if (line.isClosingFence) {
+        currentLang = null
+      }
+    }
+  }
+
+  if (currentChunk) {
+    chunks.push(currentChunk)
+  }
+
+  return chunks
+}
+
 /**
  * Escape Discord formatting characters to prevent breaking code blocks and inline code
  */
@@ -1687,6 +1778,7 @@ async function handleOpencodeSession({
       path: { id: session.id },
       body: {
         parts,
+        system: OPENCODE_SYSTEM_MESSAGE,
       },
       signal: abortController.signal,
     })

package/src/escape-backticks.test.ts

@@ -1,6 +1,6 @@
 import { test, expect } from 'vitest'
 import { Lexer } from 'marked'
-import { escapeBackticksInCodeBlocks } from './discordBot.js'
+import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord } from './discordBot.js'
 
 
 
@@ -144,3 +144,304 @@ const x = \\\`hello\\\`
 "
 `)
 })
+
+test('splitMarkdownForDiscord returns single chunk for short content', () => {
+  const result = splitMarkdownForDiscord({
+    content: 'Hello world',
+    maxLength: 100,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "Hello world",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord splits at line boundaries', () => {
+  const result = splitMarkdownForDiscord({
+    content: 'Line 1\nLine 2\nLine 3\nLine 4',
+    maxLength: 15,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "Line 1
+    Line 2
+    ",
+      "Line 3
+    Line 4",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord preserves code blocks when not split', () => {
+  const result = splitMarkdownForDiscord({
+    content: '```js\nconst x = 1\n```',
+    maxLength: 100,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    const x = 1
+    \`\`\`",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord adds closing and opening fences when splitting code block', () => {
+  const result = splitMarkdownForDiscord({
+    content: '```js\nline1\nline2\nline3\nline4\n```',
+    maxLength: 20,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    line1
+    line2
+    \`\`\`
+    ",
+      "\`\`\`js
+    line3
+    line4
+    \`\`\`
+    ",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord handles code block with language', () => {
+  const result = splitMarkdownForDiscord({
+    content: '```typescript\nconst a = 1\nconst b = 2\n```',
+    maxLength: 30,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`typescript
+    const a = 1
+    \`\`\`
+    ",
+      "\`\`\`typescript
+    const b = 2
+    \`\`\`
+    ",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord handles mixed content with code blocks', () => {
+  const result = splitMarkdownForDiscord({
+    content: 'Text before\n```js\ncode\n```\nText after',
+    maxLength: 25,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "Text before
+    \`\`\`js
+    code
+    \`\`\`
+    ",
+      "Text after",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord handles code block without language', () => {
+  const result = splitMarkdownForDiscord({
+    content: '```\nline1\nline2\n```',
+    maxLength: 12,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`
+    line1
+    \`\`\`
+    ",
+      "\`\`\`
+    line2
+    \`\`\`
+    ",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord handles multiple consecutive code blocks', () => {
+  const result = splitMarkdownForDiscord({
+    content: '```js\nfoo\n```\n```py\nbar\n```',
+    maxLength: 20,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    foo
+    \`\`\`
+    \`\`\`py
+    \`\`\`
+    ",
+      "\`\`\`py
+    bar
+    \`\`\`
+    ",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord handles empty code block', () => {
+  const result = splitMarkdownForDiscord({
+    content: 'before\n```\n```\nafter',
+    maxLength: 50,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "before
+    \`\`\`
+    \`\`\`
+    after",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord handles content exactly at maxLength', () => {
+  const result = splitMarkdownForDiscord({
+    content: '12345678901234567890',
+    maxLength: 20,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "12345678901234567890",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord handles code block only', () => {
+  const result = splitMarkdownForDiscord({
+    content: '```ts\nconst x = 1\n```',
+    maxLength: 15,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`ts
+    \`\`\`
+    ",
+      "\`\`\`ts
+    const x = 1
+    \`\`\`
+    ",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord handles code block at start with text after', () => {
+  const result = splitMarkdownForDiscord({
+    content: '```js\ncode\n```\nSome text after',
+    maxLength: 20,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    code
+    \`\`\`
+    ",
+      "Some text after",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord handles text before code block at end', () => {
+  const result = splitMarkdownForDiscord({
+    content: 'Some text before\n```js\ncode\n```',
+    maxLength: 25,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "Some text before
+    \`\`\`js
+    \`\`\`
+    ",
+      "\`\`\`js
+    code
+    \`\`\`
+    ",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord handles very long line inside code block', () => {
+  const result = splitMarkdownForDiscord({
+    content: '```js\nshort\nveryverylonglinethatexceedsmaxlength\nshort\n```',
+    maxLength: 25,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "\`\`\`js
+    short
+    \`\`\`
+    ",
+      "\`\`\`js
+    veryverylonglinethatexceedsmaxlength
+    \`\`\`
+    ",
+      "\`\`\`js
+    short
+    \`\`\`
+    ",
+    ]
+  `)
+})
+
+test('splitMarkdownForDiscord handles realistic long markdown with code block', () => {
+  const content = `Here is some explanation text before the code.
+
+\`\`\`typescript
+export function calculateTotal(items: Item[]): number {
+  let total = 0
+  for (const item of items) {
+    total += item.price * item.quantity
+  }
+  return total
+}
+
+export function formatCurrency(amount: number): string {
+  return new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+  }).format(amount)
+}
+\`\`\`
+
+And here is some text after the code block.`
+
+  const result = splitMarkdownForDiscord({
+    content,
+    maxLength: 200,
+  })
+  expect(result).toMatchInlineSnapshot(`
+    [
+      "Here is some explanation text before the code.
+
+    \`\`\`typescript
+    export function calculateTotal(items: Item[]): number {
+      let total = 0
+      for (const item of items) {
+    \`\`\`
+    ",
+      "\`\`\`typescript
+        total += item.price * item.quantity
+      }
+      return total
+    }
+
+    export function formatCurrency(amount: number): string {
+      return new Intl.NumberFormat('en-US', {
+        style: 'currency',
+    \`\`\`
+    ",
+      "\`\`\`typescript
+        currency: 'USD',
+      }).format(amount)
+    }
+    \`\`\`
+
+
+    And here is some text after the code block.",
+    ]
+  `)
+})

package/src/opencode-command.md

@@ -1,4 +1,4 @@
 ---
-description: Send current session to Kimaki Discord
+description: Create Discord thread for current session
 ---
-say "Session sent to discord!"
+Creating Discord thread for this session...

package/src/opencode-plugin.ts

@@ -39,6 +39,10 @@ export const KimakiDiscordPlugin: Plugin = async ({
         return
       }
 
+      await client.tui.showToast({
+        body: { message: 'Creating Discord thread...', variant: 'info' },
+      })
+
       try {
         const result =
           await $`npx -y kimaki send-to-discord ${sessionID} -d ${directory}`.text()

package/src/tools.ts

@@ -15,7 +15,10 @@ import { formatDistanceToNow } from 'date-fns'
 
 import { ShareMarkdown } from './markdown.js'
 import pc from 'picocolors'
-import { initializeOpencodeForDirectory } from './discordBot.js'
+import {
+  initializeOpencodeForDirectory,
+  OPENCODE_SYSTEM_MESSAGE,
+} from './discordBot.js'
 
 export async function getTools({
   onMessageCompleted,
@@ -72,10 +75,10 @@ export async function getTools({
         getClient()
           .session.prompt({
             path: { id: sessionId },
-
             body: {
               parts: [{ type: 'text', text: message }],
               model: sessionModel,
+              system: OPENCODE_SYSTEM_MESSAGE,
             },
           })
           .then(async (response) => {
@@ -149,7 +152,7 @@ export async function getTools({
               path: { id: session.data.id },
               body: {
                 parts: [{ type: 'text', text: message }],
-                // model,
+                system: OPENCODE_SYSTEM_MESSAGE,
               },
             })
             .then(async (response) => {

package/src/voice.ts

@@ -42,7 +42,17 @@ export async function transcribeAudio({
     }
 
     // Build the transcription prompt
-    let transcriptionPrompt = `Please transcribe this audio file accurately. Here is some relevant information and filenames that may be present in the audio:\n<context>\n${prompt}\n</context>\n`
+    let transcriptionPrompt = `Transcribe this audio accurately. The transcription will be sent to a coding agent (like Claude Code) to execute programming tasks.
+
+Assume the speaker is using technical and programming terminology: file paths, function names, CLI commands, package names, API names, programming concepts, etc. Prioritize technical accuracy over literal transcription - if a word sounds like a common programming term, prefer that interpretation.
+
+If the spoken message is unclear or ambiguous, rephrase it to better convey the intended meaning for a coding agent. The goal is effective communication of the user's programming intent, not a word-for-word transcription.
+
+Here are relevant filenames and context that may appear in the audio:
+<context>
+${prompt}
+</context>
+`
     if (language) {
       transcriptionPrompt += `\nThe audio is in ${language}.`
     }