shuvmaki 0.4.26

package/src/format-tables.test.ts

@@ -0,0 +1,440 @@
+import { test, expect } from 'vitest'
+import { formatMarkdownTables } from './format-tables.js'
+
+test('formats simple table', () => {
+  const input = `| Name | Age |
+| --- | --- |
+| Alice | 30 |
+| Bob | 25 |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Name  Age
+    ----- ---
+    Alice 30 
+    Bob   25 
+    \`\`\`
+    "
+  `)
+})
+
+test('formats table with varying column widths', () => {
+  const input = `| Item | Quantity | Price |
+| --- | --- | --- |
+| Apples | 10 | $5 |
+| Oranges | 3 | $2 |
+| Bananas with long name | 100 | $15.99 |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Item                   Quantity Price 
+    ---------------------- -------- ------
+    Apples                 10       $5    
+    Oranges                3        $2    
+    Bananas with long name 100      $15.99
+    \`\`\`
+    "
+  `)
+})
+
+test('strips bold formatting from cells', () => {
+  const input = `| Header | Value |
+| --- | --- |
+| **Bold text** | Normal |
+| Mixed **bold** text | Another |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Header          Value  
+    --------------- -------
+    Bold text       Normal 
+    Mixed bold text Another
+    \`\`\`
+    "
+  `)
+})
+
+test('strips italic formatting from cells', () => {
+  const input = `| Header | Value |
+| --- | --- |
+| *Italic text* | Normal |
+| _Also italic_ | Another |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Header      Value  
+    ----------- -------
+    Italic text Normal 
+    Also italic Another
+    \`\`\`
+    "
+  `)
+})
+
+test('extracts URL from links', () => {
+  const input = `| Name | Link |
+| --- | --- |
+| Google | [Click here](https://google.com) |
+| GitHub | [GitHub Home](https://github.com) |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Name   Link              
+    ------ ------------------
+    Google https://google.com
+    GitHub https://github.com
+    \`\`\`
+    "
+  `)
+})
+
+test('handles inline code in cells', () => {
+  const input = `| Function | Description |
+| --- | --- |
+| \`console.log\` | Logs to console |
+| \`Array.map\` | Maps array items |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Function    Description     
+    ----------- ----------------
+    console.log Logs to console 
+    Array.map   Maps array items
+    \`\`\`
+    "
+  `)
+})
+
+test('handles mixed formatting in single cell', () => {
+  const input = `| Description |
+| --- |
+| This has **bold**, *italic*, and \`code\` |
+| Also [a link](https://example.com) here |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Description                    
+    -------------------------------
+    This has bold, italic, and code
+    Also https://example.com here  
+    \`\`\`
+    "
+  `)
+})
+
+test('handles strikethrough text', () => {
+  const input = `| Status | Item |
+| --- | --- |
+| Done | ~~Deleted item~~ |
+| Active | Normal item |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Status Item        
+    ------ ------------
+    Done   Deleted item
+    Active Normal item 
+    \`\`\`
+    "
+  `)
+})
+
+test('preserves content before table', () => {
+  const input = `Here is some text before the table.
+
+| Col A | Col B |
+| --- | --- |
+| 1 | 2 |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "Here is some text before the table.
+
+    \`\`\`
+    Col A Col B
+    ----- -----
+    1     2    
+    \`\`\`
+    "
+  `)
+})
+
+test('preserves content after table', () => {
+  const input = `| Col A | Col B |
+| --- | --- |
+| 1 | 2 |
+
+And here is text after.`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Col A Col B
+    ----- -----
+    1     2    
+    \`\`\`
+    And here is text after."
+  `)
+})
+
+test('preserves content before and after table', () => {
+  const input = `Some intro text.
+
+| Name | Value |
+| --- | --- |
+| Key | 123 |
+
+Some outro text.`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "Some intro text.
+
+    \`\`\`
+    Name Value
+    ---- -----
+    Key  123  
+    \`\`\`
+    Some outro text."
+  `)
+})
+
+test('handles multiple tables in same content', () => {
+  const input = `First table:
+
+| A | B |
+| --- | --- |
+| 1 | 2 |
+
+Some text between.
+
+Second table:
+
+| X | Y | Z |
+| --- | --- | --- |
+| a | b | c |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "First table:
+
+    \`\`\`
+    A B
+    - -
+    1 2
+    \`\`\`
+    Some text between.
+
+    Second table:
+
+    \`\`\`
+    X Y Z
+    - - -
+    a b c
+    \`\`\`
+    "
+  `)
+})
+
+test('handles empty cells', () => {
+  const input = `| Name | Optional |
+| --- | --- |
+| Alice | |
+| | Bob |
+| | |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Name  Optional
+    ----- --------
+    Alice         
+          Bob     
+                  
+    \`\`\`
+    "
+  `)
+})
+
+test('handles single column table', () => {
+  const input = `| Items |
+| --- |
+| Apple |
+| Banana |
+| Cherry |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Items 
+    ------
+    Apple 
+    Banana
+    Cherry
+    \`\`\`
+    "
+  `)
+})
+
+test('handles single row table', () => {
+  const input = `| A | B | C | D |
+| --- | --- | --- | --- |
+| 1 | 2 | 3 | 4 |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    A B C D
+    - - - -
+    1 2 3 4
+    \`\`\`
+    "
+  `)
+})
+
+test('handles nested formatting', () => {
+  const input = `| Description |
+| --- |
+| **Bold with *nested italic* inside** |
+| *Italic with **nested bold** inside* |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Description                   
+    ------------------------------
+    Bold with nested italic inside
+    Italic with nested bold inside
+    \`\`\`
+    "
+  `)
+})
+
+test('handles image references', () => {
+  const input = `| Icon | Name |
+| --- | --- |
+| ![alt](https://example.com/icon.png) | Item 1 |
+| ![](https://cdn.test.com/img.jpg) | Item 2 |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Icon                         Name  
+    ---------------------------- ------
+    https://example.com/icon.png Item 1
+    https://cdn.test.com/img.jpg Item 2
+    \`\`\`
+    "
+  `)
+})
+
+test('preserves code blocks alongside tables', () => {
+  const input = `Some code:
+
+\`\`\`js
+const x = 1
+\`\`\`
+
+A table:
+
+| Key | Value |
+| --- | --- |
+| a | 1 |
+
+More code:
+
+\`\`\`python
+print("hello")
+\`\`\``
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "Some code:
+
+    \`\`\`js
+    const x = 1
+    \`\`\`
+
+    A table:
+
+    \`\`\`
+    Key Value
+    --- -----
+    a   1    
+    \`\`\`
+    More code:
+
+    \`\`\`python
+    print("hello")
+    \`\`\`"
+  `)
+})
+
+test('handles content without tables', () => {
+  const input = `Just some regular markdown.
+
+- List item 1
+- List item 2
+
+**Bold text** and *italic*.`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "Just some regular markdown.
+
+    - List item 1
+    - List item 2
+
+    **Bold text** and *italic*."
+  `)
+})
+
+test('handles complex real-world table', () => {
+  const input = `## API Endpoints
+
+| Method | Endpoint | Description | Auth |
+| --- | --- | --- | --- |
+| GET | \`/api/users\` | List all users | [Bearer token](https://docs.example.com/auth) |
+| POST | \`/api/users\` | Create **new** user | Required |
+| DELETE | \`/api/users/:id\` | ~~Remove~~ *Deactivate* user | Admin only |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "## API Endpoints
+
+    \`\`\`
+    Method Endpoint       Description            Auth                         
+    ------ -------------- ---------------------- -----------------------------
+    GET    /api/users     List all users         https://docs.example.com/auth
+    POST   /api/users     Create new user        Required                     
+    DELETE /api/users/:id Remove Deactivate user Admin only                   
+    \`\`\`
+    "
+  `)
+})
+
+test('handles unicode content', () => {
+  const input = `| Emoji | Name | Country |
+| --- | --- | --- |
+| 🍎 | Apple | 日本 |
+| 🍊 | Orange | España |
+| 🍌 | Banana | Ελλάδα |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Emoji Name   Country
+    ----- ------ -------
+    🍎    Apple  日本     
+    🍊    Orange España 
+    🍌    Banana Ελλάδα 
+    \`\`\`
+    "
+  `)
+})
+
+test('handles numbers and special characters', () => {
+  const input = `| Price | Discount | Final |
+| --- | --- | --- |
+| $100.00 | -15% | $85.00 |
+| €50,00 | -10% | €45,00 |
+| £75.99 | N/A | £75.99 |`
+  const result = formatMarkdownTables(input)
+  expect(result).toMatchInlineSnapshot(`
+    "\`\`\`
+    Price   Discount Final 
+    ------- -------- ------
+    $100.00 -15%     $85.00
+    €50,00  -10%     €45,00
+    £75.99  N/A      £75.99
+    \`\`\`
+    "
+  `)
+})

package/src/format-tables.ts

@@ -0,0 +1,110 @@
+// 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 {
+  const lexer = new Lexer()
+  const tokens = lexer.lex(markdown)
+
+  let result = ''
+  for (const token of tokens) {
+    if (token.type === 'table') {
+      result += formatTableToken(token as Tokens.Table)
+    } else {
+      result += token.raw
+    }
+  }
+  return result
+}
+
+function formatTableToken(table: Tokens.Table): string {
+  const headers = table.header.map((cell) => {
+    return extractCellText(cell.tokens)
+  })
+  const rows = table.rows.map((row) => {
+    return row.map((cell) => {
+      return extractCellText(cell.tokens)
+    })
+  })
+
+  const columnWidths = calculateColumnWidths(headers, rows)
+  const lines: string[] = []
+
+  lines.push(formatRow(headers, columnWidths))
+  lines.push(formatSeparator(columnWidths))
+  for (const row of rows) {
+    lines.push(formatRow(row, columnWidths))
+  }
+
+  return '```\n' + lines.join('\n') + '\n```\n'
+}
+
+function extractCellText(tokens: Token[]): string {
+  const parts: string[] = []
+  for (const token of tokens) {
+    parts.push(extractTokenText(token))
+  }
+  return parts.join('').trim()
+}
+
+function extractTokenText(token: Token): string {
+  switch (token.type) {
+    case 'text':
+    case 'codespan':
+    case 'escape':
+      return token.text
+    case 'link':
+      return token.href
+    case 'image':
+      return token.href
+    case 'strong':
+    case 'em':
+    case 'del':
+      return token.tokens ? extractCellText(token.tokens) : token.text
+    case 'br':
+      return ' '
+    default: {
+      const tokenAny = token as { tokens?: Token[]; text?: string }
+      if (tokenAny.tokens && Array.isArray(tokenAny.tokens)) {
+        return extractCellText(tokenAny.tokens)
+      }
+      if (typeof tokenAny.text === 'string') {
+        return tokenAny.text
+      }
+      return ''
+    }
+  }
+}
+
+function calculateColumnWidths(
+  headers: string[],
+  rows: string[][],
+): number[] {
+  const widths = headers.map((h) => {
+    return h.length
+  })
+  for (const row of rows) {
+    for (let i = 0; i < row.length; i++) {
+      const cell = row[i] ?? ''
+      widths[i] = Math.max(widths[i] ?? 0, cell.length)
+    }
+  }
+  return widths
+}
+
+function formatRow(cells: string[], widths: number[]): string {
+  const paddedCells = cells.map((cell, i) => {
+    return cell.padEnd(widths[i] ?? 0)
+  })
+  return paddedCells.join(' ')
+}
+
+function formatSeparator(widths: number[]): string {
+  return widths
+    .map((w) => {
+      return '-'.repeat(w)
+    })
+    .join(' ')
+}

package/src/genai-worker-wrapper.ts

@@ -0,0 +1,160 @@
+// 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'
+import { createLogger } from './logger.js'
+
+const genaiWorkerLogger = createLogger('GENAI WORKER')
+const genaiWrapperLogger = createLogger('GENAI WORKER WRAPPER')
+
+export interface GenAIWorkerOptions {
+  directory: string
+  systemMessage?: string
+  guildId: string
+  channelId: string
+  appId: string
+  geminiApiKey?: string | null
+  onAssistantOpusPacket: (packet: ArrayBuffer) => void
+  onAssistantStartSpeaking?: () => void
+  onAssistantStopSpeaking?: () => void
+  onAssistantInterruptSpeaking?: () => void
+  onToolCallCompleted?: (params: {
+    sessionId: string
+    messageId: string
+    data?: any
+    error?: any
+    markdown?: string
+  }) => void
+  onError?: (error: string) => void
+}
+
+export interface GenAIWorker {
+  sendRealtimeInput(params: {
+    audio?: { mimeType: string; data: string }
+    audioStreamEnd?: boolean
+  }): void
+  sendTextInput(text: string): void
+  interrupt(): void
+  stop(): Promise<void>
+}
+
+export function createGenAIWorker(
+  options: GenAIWorkerOptions,
+): Promise<GenAIWorker> {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(
+      new URL('../dist/genai-worker.js', import.meta.url),
+    )
+
+    // Handle messages from worker
+    worker.on('message', (message: WorkerOutMessage) => {
+      switch (message.type) {
+        case 'assistantOpusPacket':
+          options.onAssistantOpusPacket(message.packet)
+          break
+        case 'assistantStartSpeaking':
+          options.onAssistantStartSpeaking?.()
+          break
+        case 'assistantStopSpeaking':
+          options.onAssistantStopSpeaking?.()
+          break
+        case 'assistantInterruptSpeaking':
+          options.onAssistantInterruptSpeaking?.()
+          break
+        case 'toolCallCompleted':
+          options.onToolCallCompleted?.(message)
+          break
+        case 'error':
+          genaiWorkerLogger.error('Error:', message.error)
+          options.onError?.(message.error)
+          break
+        case 'ready':
+          genaiWorkerLogger.log('Ready')
+          // Resolve with the worker interface
+          resolve({
+            sendRealtimeInput({ audio, audioStreamEnd }) {
+              worker.postMessage({
+                type: 'sendRealtimeInput',
+                audio,
+                audioStreamEnd,
+              } satisfies WorkerInMessage)
+            },
+            sendTextInput(text) {
+              worker.postMessage({
+                type: 'sendTextInput',
+                text,
+              } satisfies WorkerInMessage)
+            },
+            interrupt() {
+              worker.postMessage({
+                type: 'interrupt',
+              } satisfies WorkerInMessage)
+            },
+            async stop() {
+              genaiWrapperLogger.log('Stopping worker...')
+              // Send stop message to trigger graceful shutdown
+              worker.postMessage({ type: 'stop' } satisfies WorkerInMessage)
+
+              // Wait for worker to exit gracefully (with timeout)
+              await new Promise<void>((resolve) => {
+                let resolved = false
+
+                // Listen for worker exit
+                worker.once('exit', (code) => {
+                  if (!resolved) {
+                    resolved = true
+                    genaiWrapperLogger.log(
+                      `[GENAI WORKER WRAPPER] Worker exited with code ${code}`,
+                    )
+                    resolve()
+                  }
+                })
+
+                // Timeout after 5 seconds and force terminate
+                setTimeout(() => {
+                  if (!resolved) {
+                    resolved = true
+                    genaiWrapperLogger.log(
+                      '[GENAI WORKER WRAPPER] Worker did not exit gracefully, terminating...',
+                    )
+                    worker.terminate().then(() => {
+                      genaiWrapperLogger.log('Worker terminated')
+                      resolve()
+                    })
+                  }
+                }, 5000)
+              })
+            },
+          })
+          break
+      }
+    })
+
+    // Handle worker errors
+    worker.on('error', (error) => {
+      genaiWorkerLogger.error('Worker error:', error)
+      reject(error)
+    })
+
+    worker.on('exit', (code) => {
+      if (code !== 0) {
+        genaiWorkerLogger.error(`Worker stopped with exit code ${code}`)
+      }
+    })
+
+    // Send initialization message
+    const initMessage: WorkerInMessage = {
+      type: 'init',
+      directory: options.directory,
+      systemMessage: options.systemMessage,
+      guildId: options.guildId,
+      channelId: options.channelId,
+      appId: options.appId,
+      geminiApiKey: options.geminiApiKey,
+    }
+    worker.postMessage(initMessage)
+  })
+}