shuvmaki 0.4.26

package/src/discord-utils.ts

@@ -0,0 +1,282 @@
+// 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,
+  type TextChannel,
+  type ThreadChannel,
+} from 'discord.js'
+import { Lexer } from 'marked'
+import { extractTagsArrays } from './xml.js'
+import { formatMarkdownTables } from './format-tables.js'
+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()
+  const tokens = lexer.lex(markdown)
+
+  let result = ''
+
+  for (const token of tokens) {
+    if (token.type === 'code') {
+      const escapedCode = token.text.replace(/`/g, '\\`')
+      result += '```' + (token.lang || '') + '\n' + escapedCode + '\n```\n'
+    } else {
+      result += token.raw
+    }
+  }
+
+  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
+
+  // 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) {
+      // 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)
+          }
+        }
+
+        currentLang = null
+        continue
+      }
+
+      // 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
+        }
+      } else {
+        // currentChunk is empty but line still exceeds - shouldn't happen after above check
+        currentChunk = line.text
+        if (line.inCodeBlock || line.isOpeningFence) {
+          currentLang = line.lang
+        }
+      }
+    } 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
+}
+
+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) {
+    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
+    }
+    const message = await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
+    if (i === 0) {
+      firstMessage = message
+    }
+  }
+
+  return firstMessage!
+}
+
+export async function resolveTextChannel(
+  channel: TextChannel | ThreadChannel | null | undefined,
+): Promise<TextChannel | null> {
+  if (!channel) {
+    return null
+  }
+
+  if (channel.type === ChannelType.GuildText) {
+    return channel as TextChannel
+  }
+
+  if (
+    channel.type === ChannelType.PublicThread ||
+    channel.type === ChannelType.PrivateThread ||
+    channel.type === ChannelType.AnnouncementThread
+  ) {
+    const parentId = channel.parentId
+    if (parentId) {
+      const parent = await channel.guild.channels.fetch(parentId)
+      if (parent?.type === ChannelType.GuildText) {
+        return parent as TextChannel
+      }
+    }
+  }
+
+  return null
+}
+
+export function escapeDiscordFormatting(text: string): string {
+  return text
+    .replace(/```/g, '\\`\\`\\`')
+    .replace(/````/g, '\\`\\`\\`\\`')
+}
+
+export function getKimakiMetadata(textChannel: TextChannel | null): {
+  projectDirectory?: string
+  channelAppId?: string
+} {
+  if (!textChannel?.topic) {
+    return {}
+  }
+
+  const extracted = extractTagsArrays({
+    xml: textChannel.topic,
+    tags: ['kimaki.directory', 'kimaki.app'],
+  })
+
+  const projectDirectory = extracted['kimaki.directory']?.[0]?.trim()
+  const channelAppId = extracted['kimaki.app']?.[0]?.trim()
+
+  return { projectDirectory, channelAppId }
+}

package/src/escape-backticks.test.ts

@@ -0,0 +1,447 @@
+import { test, expect } from 'vitest'
+import { Lexer } from 'marked'
+import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord } from './discord-utils.js'
+
+
+
+test('escapes single backticks in code blocks', () => {
+  const input = '```js\nconst x = `hello`\n```'
+  const result = escapeBackticksInCodeBlocks(input)
+
+  expect(result).toMatchInlineSnapshot(`
+"\`\`\`js
+const x = \\\`hello\\\`
+\`\`\`
+"
+`)
+})
+
+test('escapes backticks in code blocks with language', () => {
+  const input = '```typescript\nconst greeting = `Hello, ${name}!`\nconst inline = `test`\n```'
+  const result = escapeBackticksInCodeBlocks(input)
+
+  expect(result).toMatchInlineSnapshot(`
+"\`\`\`typescript
+const greeting = \\\`Hello, \${name}!\\\`
+const inline = \\\`test\\\`
+\`\`\`
+"
+`)
+})
+
+test('does not escape backticks outside code blocks', () => {
+  const input = 'This is `inline code` and this is a code block:\n```\nconst x = `template`\n```'
+  const result = escapeBackticksInCodeBlocks(input)
+
+  expect(result).toMatchInlineSnapshot(`
+"This is \`inline code\` and this is a code block:
+\`\`\`
+const x = \\\`template\\\`
+\`\`\`
+"
+`)
+})
+
+test('handles multiple code blocks', () => {
+  const input = `First block:
+\`\`\`js
+const a = \`test\`
+\`\`\`
+
+Some text with \`inline\` code
+
+Second block:
+\`\`\`python
+name = f\`hello {world}\`
+\`\`\``
+
+  const result = escapeBackticksInCodeBlocks(input)
+
+  expect(result).toMatchInlineSnapshot(`
+"First block:
+\`\`\`js
+const a = \\\`test\\\`
+\`\`\`
+
+
+Some text with \`inline\` code
+
+Second block:
+\`\`\`python
+name = f\\\`hello {world}\\\`
+\`\`\`
+"
+`)
+})
+
+test('handles code blocks without language', () => {
+  const input = '```\nconst x = `value`\n```'
+  const result = escapeBackticksInCodeBlocks(input)
+
+  expect(result).toMatchInlineSnapshot(`
+"\`\`\`
+const x = \\\`value\\\`
+\`\`\`
+"
+`)
+})
+
+test('handles nested backticks in code blocks', () => {
+  const input = '```js\nconst nested = `outer ${`inner`} text`\n```'
+  const result = escapeBackticksInCodeBlocks(input)
+
+  expect(result).toMatchInlineSnapshot(`
+"\`\`\`js
+const nested = \\\`outer \${\\\`inner\\\`} text\\\`
+\`\`\`
+"
+`)
+})
+
+test('preserves markdown outside code blocks', () => {
+  const input = `# Heading
+
+This is **bold** and *italic* text
+
+\`\`\`js
+const code = \`with template\`
+\`\`\`
+
+- List item 1
+- List item 2`
+
+  const result = escapeBackticksInCodeBlocks(input)
+
+  expect(result).toMatchInlineSnapshot(`
+"# Heading
+
+This is **bold** and *italic* text
+
+\`\`\`js
+const code = \\\`with template\\\`
+\`\`\`
+
+
+- List item 1
+- List item 2"
+`)
+})
+
+test('does not escape code block delimiter backticks', () => {
+  const input = '```js\nconst x = `hello`\n```'
+  const result = escapeBackticksInCodeBlocks(input)
+
+  expect(result.startsWith('```')).toBe(true)
+  expect(result.endsWith('```\n')).toBe(true)
+  expect(result).toContain('\\`hello\\`')
+  expect(result).not.toContain('\\`\\`\\`js')
+  expect(result).not.toContain('\\`\\`\\`\n')
+
+  expect(result).toMatchInlineSnapshot(`
+"\`\`\`js
+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.",
+    ]
+  `)
+})