@otto-assistant/bridge 0.4.92

package/dist/format-tables.js

@@ -0,0 +1,302 @@
+// 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 } from 'marked';
+import { ButtonStyle, ComponentType, SeparatorSpacingSize, } from 'discord.js';
+import { parseInlineHtmlRenderables, } from './html-components.js';
+// 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, options = {}) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    const segments = [];
+    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, 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, options = {}) {
+    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 = [];
+        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 = {
+            type: ComponentType.Container,
+            components: children,
+        };
+        return {
+            type: 'components',
+            components: [container],
+        };
+    });
+}
+function buildRenderedRow({ headers, row, options, }) {
+    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, }) {
+    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, }) {
+    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 = buttonCells.map((buttonCell) => {
+        return {
+            type: ComponentType.Button,
+            custom_id: buttonCell.customId,
+            label: buttonCell.label,
+            style: toButtonStyle({ variant: buttonCell.variant }),
+            disabled: buttonCell.disabled,
+        };
+    });
+    const actionRow = {
+        type: ComponentType.ActionRow,
+        components: buttons,
+    };
+    return {
+        components: [
+            {
+                type: ComponentType.TextDisplay,
+                content: lines.join('\n'),
+            },
+            actionRow,
+        ],
+        componentCost: 2 + buttons.length,
+    };
+}
+function chunkRowsByComponentLimit({ rows, }) {
+    const chunks = [];
+    let currentChunk = [];
+    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, }) {
+    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, }) {
+    if (cell.type === 'button') {
+        return cell.label;
+    }
+    return cell.text;
+}
+function extractRenderableText({ renderables, fallbackText, }) {
+    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, }) {
+    if (variant === 'primary') {
+        return ButtonStyle.Primary;
+    }
+    if (variant === 'success') {
+        return ButtonStyle.Success;
+    }
+    if (variant === 'danger') {
+        return ButtonStyle.Danger;
+    }
+    return ButtonStyle.Secondary;
+}
+function extractCellText(tokens) {
+    const parts = [];
+    for (const token of tokens) {
+        parts.push(extractTokenText(token));
+    }
+    return parts.join('').trim();
+}
+function extractTokenText(token) {
+    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;
+            if (tokenAny.tokens && Array.isArray(tokenAny.tokens)) {
+                return extractCellText(tokenAny.tokens);
+            }
+            if (typeof tokenAny.text === 'string') {
+                return tokenAny.text;
+            }
+            return '';
+        }
+    }
+}

package/dist/format-tables.test.js

@@ -0,0 +1,308 @@
+import { test, expect, describe } from 'vitest';
+import { splitTablesFromMarkdown, buildTableComponents, } from './format-tables.js';
+import { Lexer } from 'marked';
+function parseTable(markdown) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    return tokens.find((t) => t.type === 'table');
+}
+/** Extract the first container's children from buildTableComponents result */
+function getContainerChildren(segments) {
+    const seg = segments[0];
+    if (seg.type !== 'components') {
+        throw new Error('Expected components segment');
+    }
+    const container = seg.components[0];
+    return container.components;
+}
+describe('buildTableComponents', () => {
+    test('builds container with key-value TextDisplays', () => {
+        const table = parseTable(`| Name | Age |
+| --- | --- |
+| Alice | 30 |
+| Bob | 25 |`);
+        const result = buildTableComponents(table);
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "components": [
+            {
+              "components": [
+                {
+                  "content": "**Name** Alice
+      **Age** 30",
+                  "type": 10,
+                },
+                {
+                  "divider": true,
+                  "spacing": 1,
+                  "type": 14,
+                },
+                {
+                  "content": "**Name** Bob
+      **Age** 25",
+                  "type": 10,
+                },
+              ],
+              "type": 17,
+            },
+          ],
+          "type": "components",
+        },
+      ]
+    `);
+    });
+    test('adds separators between row groups', () => {
+        const table = parseTable(`| Key | Value |
+| --- | --- |
+| a | 1 |
+| b | 2 |
+| c | 3 |`);
+        const result = buildTableComponents(table);
+        const types = getContainerChildren(result).map((c) => c.type);
+        // type 10 = TextDisplay, type 14 = Separator
+        expect(types).toMatchInlineSnapshot(`
+      [
+        10,
+        14,
+        10,
+        14,
+        10,
+      ]
+    `);
+    });
+    test('single-row table has one TextDisplay, no separators', () => {
+        const table = parseTable(`| Method | Endpoint |
+| --- | --- |
+| GET | /api/users |`);
+        const result = buildTableComponents(table);
+        const children = getContainerChildren(result);
+        expect(children).toHaveLength(1);
+        expect(children[0].type).toBe(10);
+        expect(children[0].content).toMatchInlineSnapshot(`
+      "**Method** GET
+      **Endpoint** /api/users"
+    `);
+    });
+    test('splits large table into multiple container segments', () => {
+        // 25 rows: exceeds 19 rows per container, so splits into 2 containers
+        const headers = '| A | B |';
+        const sep = '| --- | --- |';
+        const rows = Array.from({ length: 25 }, (_, i) => {
+            return `| ${i}a | ${i}b |`;
+        }).join('\n');
+        const table = parseTable(`${headers}\n${sep}\n${rows}`);
+        const result = buildTableComponents(table);
+        expect(result).toHaveLength(2);
+        expect(result[0].type).toBe('components');
+        expect(result[1].type).toBe('components');
+        // First container has 20 rows (20 TDs + 19 seps = 39 children)
+        const firstChildren = getContainerChildren([result[0]]);
+        expect(firstChildren).toHaveLength(20 + 19);
+        // Second container has 5 rows (5 TDs + 4 seps = 9 children)
+        const secondChildren = getContainerChildren([result[1]]);
+        expect(secondChildren).toHaveLength(5 + 4);
+    });
+    test('strips formatting from cells', () => {
+        const table = parseTable(`| Header | Value |
+| --- | --- |
+| **Bold text** | Normal |
+| *Italic* | \`code\` |`);
+        const result = buildTableComponents(table);
+        const children = getContainerChildren(result);
+        expect(children[0].content).toMatchInlineSnapshot(`
+      "**Header** Bold text
+      **Value** Normal"
+    `);
+    });
+    test('renders button cells as action rows inside the container', () => {
+        const table = parseTable(`| Name | Action |
+| --- | --- |
+| feature-a | <button id="delete-a" variant="secondary">Delete</button> |`);
+        const result = buildTableComponents(table, {
+            resolveButtonCustomId: ({ button }) => {
+                return `html_action:${button.id}`;
+            },
+        });
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "components": [
+            {
+              "components": [
+                {
+                  "content": "**Name** feature-a",
+                  "type": 10,
+                },
+                {
+                  "components": [
+                    {
+                      "custom_id": "html_action:delete-a",
+                      "disabled": false,
+                      "label": "Delete",
+                      "style": 2,
+                      "type": 2,
+                    },
+                  ],
+                  "type": 1,
+                },
+              ],
+              "type": 17,
+            },
+          ],
+          "type": "components",
+        },
+      ]
+    `);
+    });
+    test('falls back to button text when no resolver is provided', () => {
+        const table = parseTable(`| Name | Action |
+| --- | --- |
+| feature-a | <button id="delete-a" variant="secondary">Delete</button> |`);
+        const result = buildTableComponents(table);
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "components": [
+            {
+              "components": [
+                {
+                  "content": "**Name** feature-a
+      **Action** Delete",
+                  "type": 10,
+                },
+              ],
+              "type": 17,
+            },
+          ],
+          "type": "components",
+        },
+      ]
+    `);
+    });
+    test('renders wide rows with buttons without using sections', () => {
+        const table = parseTable(`| Thread | Name | Status | Created | Folder | Action |
+| --- | --- | --- | --- | --- | --- |
+| thread | feature-a | merged | 1m ago | /tmp/feature-a | <button id="delete-a" variant="secondary">Delete</button> |`);
+        const result = buildTableComponents(table, {
+            resolveButtonCustomId: ({ button }) => {
+                return `html_action:${button.id}`;
+            },
+        });
+        expect(result).toMatchInlineSnapshot(`
+      [
+        {
+          "components": [
+            {
+              "components": [
+                {
+                  "content": "**Thread** thread
+      **Name** feature-a
+      **Status** merged
+      **Created** 1m ago
+      **Folder** /tmp/feature-a",
+                  "type": 10,
+                },
+                {
+                  "components": [
+                    {
+                      "custom_id": "html_action:delete-a",
+                      "disabled": false,
+                      "label": "Delete",
+                      "style": 2,
+                      "type": 2,
+                    },
+                  ],
+                  "type": 1,
+                },
+              ],
+              "type": 17,
+            },
+          ],
+          "type": "components",
+        },
+      ]
+    `);
+    });
+});
+describe('splitTablesFromMarkdown', () => {
+    test('returns single text segment for content without tables', () => {
+        const result = splitTablesFromMarkdown('Just some text.\n\nMore text.');
+        expect(result).toHaveLength(1);
+        expect(result[0].type).toBe('text');
+    });
+    test('returns single components segment for table-only content', () => {
+        const result = splitTablesFromMarkdown(`| A | B |
+| --- | --- |
+| 1 | 2 |`);
+        expect(result).toHaveLength(1);
+        expect(result[0].type).toBe('components');
+    });
+    test('splits text before and after table into separate segments', () => {
+        const result = splitTablesFromMarkdown(`Text before.
+
+| Key | Value |
+| --- | --- |
+| a | 1 |
+
+Text after.`);
+        expect(result).toHaveLength(3);
+        expect(result[0].type).toBe('text');
+        expect(result[1].type).toBe('components');
+        expect(result[2].type).toBe('text');
+    });
+    test('handles multiple tables with text between', () => {
+        const result = splitTablesFromMarkdown(`First table:
+
+| A | B |
+| --- | --- |
+| 1 | 2 |
+
+Middle text.
+
+| X | Y |
+| --- | --- |
+| a | b |`);
+        expect(result).toHaveLength(4);
+        expect(result.map((s) => s.type)).toMatchInlineSnapshot(`
+      [
+        "text",
+        "components",
+        "text",
+        "components",
+      ]
+    `);
+    });
+    test('splits oversized table into multiple component segments', () => {
+        const headers = '| A | B |';
+        const sep = '| --- | --- |';
+        const rows = Array.from({ length: 25 }, (_, i) => {
+            return `| ${i}a | ${i}b |`;
+        }).join('\n');
+        const result = splitTablesFromMarkdown(`${headers}\n${sep}\n${rows}`);
+        // 25 rows splits into 2 container segments
+        expect(result).toHaveLength(2);
+        expect(result.every((s) => s.type === 'components')).toBe(true);
+    });
+    test('preserves code blocks alongside tables', () => {
+        const result = splitTablesFromMarkdown(`Some code:
+
+\`\`\`js
+const x = 1
+\`\`\`
+
+| Key | Value |
+| --- | --- |
+| a | 1 |
+
+Done.`);
+        const types = result.map((s) => s.type);
+        expect(types).toMatchInlineSnapshot(`
+      [
+        "text",
+        "components",
+        "text",
+      ]
+    `);
+    });
+});

package/dist/forum-sync/config.js

@@ -0,0 +1,79 @@
+// 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';
+const forumLogger = createLogger('FORUM');
+const LEGACY_CONFIG_FILE = 'forum-sync.json';
+function isForumSyncDirection(value) {
+    return value === 'discord-to-files' || value === 'bidirectional';
+}
+function resolveOutputDir(outputDir) {
+    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 }) {
+    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;
+    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.forums;
+    if (!Array.isArray(forums))
+        return;
+    for (const item of forums) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const entry = item;
+        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 }) {
+    if (!appId)
+        return [];
+    // Migrate legacy JSON file on first run
+    await migrateLegacyConfig({ appId });
+    const rows = await getForumSyncConfigs({ appId });
+    return rows.map((row) => ({
+        forumChannelId: row.forumChannelId,
+        outputDir: resolveOutputDir(row.outputDir),
+        direction: isForumSyncDirection(row.direction)
+            ? row.direction
+            : 'bidirectional',
+    }));
+}