kimaki 0.4.24 → 0.4.26

package/src/discord-utils.ts

@@ -1,3 +1,7 @@
+// Discord-specific utility functions.
+// Handles markdown splitting for Discord's 2000-char limit, code block escaping,
+// thread message sending, and channel metadata extraction from topic tags.
+
 import {
   ChannelType,
   type Message,
@@ -12,6 +16,8 @@ import { createLogger } from './logger.js'
 const discordLogger = createLogger('DISCORD')
 
 export const SILENT_MESSAGE_FLAGS = 4 | 4096
+// Same as SILENT but without SuppressNotifications - triggers badge/notification
+export const NOTIFY_MESSAGE_FLAGS = 4
 
 export function escapeBackticksInCodeBlocks(markdown: string): string {
   const lexer = new Lexer()
@@ -79,31 +85,93 @@ export function splitMarkdownForDiscord({
   let currentChunk = ''
   let currentLang: string | null = null
 
+  // helper to split a long line into smaller pieces at word boundaries or hard breaks
+  const splitLongLine = (text: string, available: number, inCode: boolean): string[] => {
+    const pieces: string[] = []
+    let remaining = text
+
+    while (remaining.length > available) {
+      let splitAt = available
+      // for non-code, try to split at word boundary
+      if (!inCode) {
+        const lastSpace = remaining.lastIndexOf(' ', available)
+        if (lastSpace > available * 0.5) {
+          splitAt = lastSpace + 1
+        }
+      }
+      pieces.push(remaining.slice(0, splitAt))
+      remaining = remaining.slice(splitAt)
+    }
+    if (remaining) {
+      pieces.push(remaining)
+    }
+    return pieces
+  }
+
   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 (wouldExceed) {
+      // handle case where single line is longer than maxLength
+      if (line.text.length > maxLength) {
+        // first, flush current chunk if any
+        if (currentChunk) {
+          if (currentLang !== null) {
+            currentChunk += '```\n'
+          }
+          chunks.push(currentChunk)
+          currentChunk = ''
+        }
+
+        // calculate overhead for code block markers
+        const codeBlockOverhead = line.inCodeBlock ? ('```' + line.lang + '\n').length + '```\n'.length : 0
+        const availablePerChunk = maxLength - codeBlockOverhead - 50 // safety margin
+
+        const pieces = splitLongLine(line.text, availablePerChunk, line.inCodeBlock)
+
+        for (let i = 0; i < pieces.length; i++) {
+          const piece = pieces[i]!
+          if (line.inCodeBlock) {
+            chunks.push('```' + line.lang + '\n' + piece + '```\n')
+          } else {
+            chunks.push(piece)
+          }
+        }
 
-      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
+      // normal case: line fits in a chunk but current chunk would overflow
+      if (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
         }
-        currentLang = lang
       } else {
+        // currentChunk is empty but line still exceeds - shouldn't happen after above check
         currentChunk = line.text
-        currentLang = null
+        if (line.inCodeBlock || line.isOpeningFence) {
+          currentLang = line.lang
+        }
       }
     } else {
       currentChunk += line.text
@@ -125,12 +193,18 @@ export function splitMarkdownForDiscord({
 export async function sendThreadMessage(
   thread: ThreadChannel,
   content: string,
+  options?: { flags?: number }
 ): Promise<Message> {
   const MAX_LENGTH = 2000
 
   content = formatMarkdownTables(content)
   content = escapeBackticksInCodeBlocks(content)
 
+  // If custom flags provided, send as single message (no chunking)
+  if (options?.flags !== undefined) {
+    return thread.send({ content, flags: options.flags })
+  }
+
   const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH })
 
   if (chunks.length > 1) {

package/src/format-tables.ts

@@ -1,3 +1,7 @@
+// Markdown table to code block converter.
+// Discord doesn't render GFM tables, so this converts them to
+// space-aligned code blocks for proper monospace display.
+
 import { Lexer, type Token, type Tokens } from 'marked'
 
 export function formatMarkdownTables(markdown: string): string {

package/src/genai-worker-wrapper.ts

@@ -1,3 +1,7 @@
+// Main thread interface for the GenAI worker.
+// Spawns and manages the worker thread, handling message passing for
+// audio input/output, tool call completions, and graceful shutdown.
+
 import { Worker } from 'node:worker_threads'
 import type { WorkerInMessage, WorkerOutMessage } from './worker-types.js'
 import type { Tool as AITool } from 'ai'

package/src/genai-worker.ts

@@ -1,3 +1,7 @@
+// Worker thread for GenAI voice processing.
+// Runs in a separate thread to handle audio encoding/decoding without blocking.
+// Resamples 24kHz GenAI output to 48kHz stereo Opus packets for Discord.
+
 import { parentPort, threadId } from 'node:worker_threads'
 import { createWriteStream, type WriteStream } from 'node:fs'
 import { mkdir } from 'node:fs/promises'

package/src/genai.ts

@@ -1,3 +1,7 @@
+// Google GenAI Live session manager for real-time voice interactions.
+// Establishes bidirectional audio streaming with Gemini, handles tool calls,
+// and manages the assistant's audio output for Discord voice channels.
+
 import {
   GoogleGenAI,
   LiveServerMessage,