@otto-assistant/bridge 0.4.92

package/src/format-tables.ts

@@ -0,0 +1,445 @@
+// Markdown table formatter for Discord.
+// Converts GFM tables to Discord Components V2 (ContainerBuilder with TextDisplay
+// key-value pairs and Separators between row groups). Large tables are split
+// across multiple Container components to stay within the 40-component limit.
+
+import { Lexer, type Token, type Tokens } from 'marked'
+import {
+  ButtonStyle,
+  ComponentType,
+  SeparatorSpacingSize,
+  type APIActionRowComponent,
+  type APIButtonComponent,
+  type APIContainerComponent,
+  type APITextDisplayComponent,
+  type APISeparatorComponent,
+  type APIMessageTopLevelComponent,
+} from 'discord.js'
+import {
+  parseInlineHtmlRenderables,
+  type HtmlButtonRenderable,
+  type HtmlRenderable,
+} from './html-components.js'
+
+export type ContentSegment =
+  | { type: 'text'; text: string }
+  | { type: 'components'; components: APIMessageTopLevelComponent[] }
+
+type TableRenderOptions = {
+  resolveButtonCustomId?: ({
+    button,
+  }: {
+    button: HtmlButtonRenderable
+  }) => string | Error
+}
+
+type RenderedTableCell =
+  | { type: 'text'; text: string }
+  | {
+      type: 'button'
+      label: string
+      customId: string
+      variant: HtmlButtonRenderable['variant']
+      disabled: boolean
+    }
+
+type RenderedTableRow = {
+  components: Array<
+    APITextDisplayComponent | APIActionRowComponent<APIButtonComponent>
+  >
+  componentCost: number
+}
+
+// Max 40 components per message (nested components count toward the limit).
+// Row cost is dynamic now because a table row can render as a plain TextDisplay
+// or as a TextDisplay plus an Action Row holding one or more buttons.
+const MAX_COMPONENTS = 40
+
+/**
+ * Split markdown into text and table component segments.
+ * Tables are rendered as CV2 Container components with bold key-value TextDisplay
+ * pairs. Large tables are split across multiple component segments.
+ */
+export function splitTablesFromMarkdown(
+  markdown: string,
+  options: TableRenderOptions = {},
+): ContentSegment[] {
+  const lexer = new Lexer()
+  const tokens = lexer.lex(markdown)
+  const segments: ContentSegment[] = []
+  let textBuffer = ''
+
+  for (const token of tokens) {
+    if (token.type === 'table') {
+      if (textBuffer.trim()) {
+        segments.push({ type: 'text', text: textBuffer })
+        textBuffer = ''
+      }
+      const componentSegments = buildTableComponents(token as Tokens.Table, options)
+      segments.push(...componentSegments)
+    } else {
+      textBuffer += token.raw
+    }
+  }
+
+  if (textBuffer.trim()) {
+    segments.push({ type: 'text', text: textBuffer })
+  }
+
+  return segments
+}
+
+/**
+ * Build CV2 components for a table. Plain rows render as one TextDisplay with
+ * bold key-value lines. Rows with resolved button cells render as a TextDisplay
+ * plus an Action Row so wide tables do not violate Section's 1-3 text child
+ * limit. Large tables are split into multiple Containers using a dynamic
+ * component-budget check.
+ */
+export function buildTableComponents(
+  table: Tokens.Table,
+  options: TableRenderOptions = {},
+): ContentSegment[] {
+  const headers = table.header.map((cell) => {
+    return extractCellText(cell.tokens)
+  })
+  const rows = table.rows.map((row) => {
+    return buildRenderedRow({
+      headers,
+      row,
+      options,
+    })
+  })
+
+  const chunks = chunkRowsByComponentLimit({ rows })
+
+  return chunks.map((chunkRows) => {
+    const children: Array<
+      | APITextDisplayComponent
+      | APIActionRowComponent<APIButtonComponent>
+      | APISeparatorComponent
+    > = []
+
+    for (let i = 0; i < chunkRows.length; i++) {
+      if (i > 0) {
+        children.push({
+          type: ComponentType.Separator,
+          divider: true,
+          spacing: SeparatorSpacingSize.Small,
+        })
+      }
+      children.push(...chunkRows[i]!.components)
+    }
+
+    const container: APIContainerComponent = {
+      type: ComponentType.Container,
+      components: children,
+    }
+
+    return {
+      type: 'components' as const,
+      components: [container] as APIMessageTopLevelComponent[],
+    }
+  })
+}
+
+function buildRenderedRow({
+  headers,
+  row,
+  options,
+}: {
+  headers: string[]
+  row: Tokens.TableCell[]
+  options: TableRenderOptions
+}): RenderedTableRow {
+  const renderedCells = row.map((cell) => {
+    return renderTableCell({ cell, options })
+  })
+  const buttonCellCount = renderedCells.filter((cell) => {
+    return cell.type === 'button'
+  }).length
+
+  if (buttonCellCount > 0) {
+    return buildButtonRow({
+      headers,
+      cells: renderedCells,
+    })
+  }
+
+  return buildTextRow({
+    headers,
+    cells: renderedCells,
+  })
+}
+
+function buildTextRow({
+  headers,
+  cells,
+}: {
+  headers: string[]
+  cells: RenderedTableCell[]
+}): RenderedTableRow {
+  const lines = headers.map((key, index) => {
+    const cell = cells[index]
+    const value = cell ? getRenderedCellText({ cell }) : ''
+    return `**${key}** ${value}`
+  })
+
+  return {
+    components: [
+      {
+        type: ComponentType.TextDisplay,
+        content: lines.join('\n'),
+      },
+    ],
+    componentCost: 1,
+  }
+}
+
+function buildButtonRow({
+  headers,
+  cells,
+}: {
+  headers: string[]
+  cells: RenderedTableCell[]
+}): RenderedTableRow {
+  const buttonCells = cells.filter((cell) => {
+    return cell.type === 'button'
+  })
+  if (buttonCells.length === 0 || buttonCells.length > 5) {
+    return buildTextRow({ headers, cells })
+  }
+
+  const lines = headers.flatMap((header, index) => {
+    const cell = cells[index]
+    if (!cell || cell.type === 'button') {
+      return []
+    }
+
+    return [`**${header}** ${cell.text}`]
+  })
+  if (lines.length === 0) {
+    return buildTextRow({ headers, cells })
+  }
+
+  const buttons: APIButtonComponent[] = buttonCells.map((buttonCell) => {
+    return {
+      type: ComponentType.Button,
+      custom_id: buttonCell.customId,
+      label: buttonCell.label,
+      style: toButtonStyle({ variant: buttonCell.variant }),
+      disabled: buttonCell.disabled,
+    }
+  })
+
+  const actionRow: APIActionRowComponent<APIButtonComponent> = {
+    type: ComponentType.ActionRow,
+    components: buttons,
+  }
+
+  return {
+    components: [
+      {
+        type: ComponentType.TextDisplay,
+        content: lines.join('\n'),
+      },
+      actionRow,
+    ],
+    componentCost: 2 + buttons.length,
+  }
+}
+
+function chunkRowsByComponentLimit({
+  rows,
+}: {
+  rows: RenderedTableRow[]
+}): RenderedTableRow[][] {
+  const chunks: RenderedTableRow[][] = []
+  let currentChunk: RenderedTableRow[] = []
+  let currentCost = 1
+
+  for (const row of rows) {
+    const separatorCost = currentChunk.length > 0 ? 1 : 0
+    const nextCost = currentCost + separatorCost + row.componentCost
+
+    if (currentChunk.length > 0 && nextCost > MAX_COMPONENTS) {
+      chunks.push(currentChunk)
+      currentChunk = [row]
+      currentCost = 1 + row.componentCost
+      continue
+    }
+
+    currentChunk.push(row)
+    currentCost = nextCost
+  }
+
+  if (currentChunk.length > 0) {
+    chunks.push(currentChunk)
+  }
+
+  return chunks
+}
+
+function renderTableCell({
+  cell,
+  options,
+}: {
+  cell: Tokens.TableCell
+  options: TableRenderOptions
+}): RenderedTableCell {
+  const hasHtmlToken = cell.tokens.some((token) => {
+    return token.type === 'html'
+  })
+  if (!hasHtmlToken) {
+    return {
+      type: 'text',
+      text: extractCellText(cell.tokens),
+    }
+  }
+
+  const renderables = parseInlineHtmlRenderables({ html: cell.text })
+  if (renderables instanceof Error) {
+    return {
+      type: 'text',
+      text: extractRenderableText({ renderables: undefined, fallbackText: cell.text }),
+    }
+  }
+
+  const buttonRenderables = renderables.filter((renderable) => {
+    return renderable.type === 'button'
+  })
+  if (buttonRenderables.length !== 1) {
+    return {
+      type: 'text',
+      text: extractRenderableText({ renderables, fallbackText: cell.text }),
+    }
+  }
+
+  const hasNonWhitespaceText = renderables.some((renderable) => {
+    if (renderable.type !== 'text') {
+      return false
+    }
+    return renderable.text.trim().length > 0
+  })
+  if (hasNonWhitespaceText) {
+    return {
+      type: 'text',
+      text: extractRenderableText({ renderables, fallbackText: cell.text }),
+    }
+  }
+
+  const button = buttonRenderables[0]!
+  const customId = options.resolveButtonCustomId?.({ button })
+  if (!customId || customId instanceof Error) {
+    return {
+      type: 'text',
+      text: button.label,
+    }
+  }
+
+  return {
+    type: 'button',
+    label: button.label,
+    customId,
+    variant: button.variant,
+    disabled: button.disabled,
+  }
+}
+
+function getRenderedCellText({
+  cell,
+}: {
+  cell: RenderedTableCell
+}): string {
+  if (cell.type === 'button') {
+    return cell.label
+  }
+  return cell.text
+}
+
+function extractRenderableText({
+  renderables,
+  fallbackText,
+}: {
+  renderables?: HtmlRenderable[]
+  fallbackText: string
+}): string {
+  if (!renderables) {
+    return fallbackText.replace(/\s+/g, ' ').trim()
+  }
+
+  const text = renderables
+    .map((renderable) => {
+      if (renderable.type === 'button') {
+        return renderable.label
+      }
+      return renderable.text
+    })
+    .join(' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+
+  if (text.length > 0) {
+    return text
+  }
+
+  return fallbackText.replace(/\s+/g, ' ').trim()
+}
+
+function toButtonStyle({
+  variant,
+}: {
+  variant: HtmlButtonRenderable['variant']
+}):
+  | ButtonStyle.Primary
+  | ButtonStyle.Secondary
+  | ButtonStyle.Success
+  | ButtonStyle.Danger {
+  if (variant === 'primary') {
+    return ButtonStyle.Primary
+  }
+  if (variant === 'success') {
+    return ButtonStyle.Success
+  }
+  if (variant === 'danger') {
+    return ButtonStyle.Danger
+  }
+  return ButtonStyle.Secondary
+}
+
+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 ''
+    }
+  }
+}

package/src/forum-sync/config.ts

@@ -0,0 +1,92 @@
+// Forum sync configuration from SQLite database.
+// Reads forum_sync_configs table and resolves relative output dirs.
+// On first run, migrates any existing forum-sync.json into the DB.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import YAML from 'yaml'
+import { getDataDir } from '../config.js'
+import { getForumSyncConfigs, upsertForumSyncConfig } from '../database.js'
+import { createLogger } from '../logger.js'
+import type { ForumSyncDirection, LoadedForumConfig } from './types.js'
+
+const forumLogger = createLogger('FORUM')
+
+const LEGACY_CONFIG_FILE = 'forum-sync.json'
+
+function isForumSyncDirection(value: unknown): value is ForumSyncDirection {
+  return value === 'discord-to-files' || value === 'bidirectional'
+}
+
+function resolveOutputDir(outputDir: string): string {
+  if (path.isAbsolute(outputDir)) return outputDir
+  return path.resolve(getDataDir(), outputDir)
+}
+
+/**
+ * One-time migration: if the legacy forum-sync.json exists, import its entries
+ * into the DB and rename the file so it's not re-imported on next startup.
+ */
+async function migrateLegacyConfig({ appId }: { appId: string }) {
+  const configPath = path.join(getDataDir(), LEGACY_CONFIG_FILE)
+  if (!fs.existsSync(configPath)) return
+
+  forumLogger.log(`Migrating legacy ${LEGACY_CONFIG_FILE} into database...`)
+
+  const raw = fs.readFileSync(configPath, 'utf8')
+  let parsed: unknown
+  try {
+    parsed = YAML.parse(raw)
+  } catch {
+    forumLogger.warn(
+      `Failed to parse legacy ${LEGACY_CONFIG_FILE}, skipping migration`,
+    )
+    return
+  }
+
+  if (!parsed || typeof parsed !== 'object') return
+  const forums = (parsed as Record<string, unknown>).forums
+  if (!Array.isArray(forums)) return
+
+  for (const item of forums) {
+    if (!item || typeof item !== 'object') continue
+    const entry = item as Record<string, unknown>
+    const forumChannelId =
+      typeof entry.forumChannelId === 'string' ? entry.forumChannelId : ''
+    const outputDir = typeof entry.outputDir === 'string' ? entry.outputDir : ''
+    const direction = isForumSyncDirection(entry.direction)
+      ? entry.direction
+      : 'bidirectional'
+    if (!forumChannelId || !outputDir) continue
+
+    await upsertForumSyncConfig({
+      appId,
+      forumChannelId,
+      outputDir: resolveOutputDir(outputDir),
+      direction,
+    })
+  }
+
+  // Rename so we don't re-import next time
+  const backupPath = configPath + '.migrated'
+  fs.renameSync(configPath, backupPath)
+  forumLogger.log(
+    `Legacy config migrated and renamed to ${path.basename(backupPath)}`,
+  )
+}
+
+export async function readForumSyncConfig({ appId }: { appId?: string }) {
+  if (!appId) return []
+
+  // Migrate legacy JSON file on first run
+  await migrateLegacyConfig({ appId })
+
+  const rows = await getForumSyncConfigs({ appId })
+  return rows.map<LoadedForumConfig>((row) => ({
+    forumChannelId: row.forumChannelId,
+    outputDir: resolveOutputDir(row.outputDir),
+    direction: isForumSyncDirection(row.direction)
+      ? row.direction
+      : 'bidirectional',
+  }))
+}