kimaki 0.4.58 → 0.4.59

package/dist/cli.js

@@ -7,6 +7,7 @@ import { intro, outro, text, password, note, cancel, isCancel, confirm, log, mul
 import { deduplicateByKey, generateBotInstallUrl, abbreviatePath } from './utils.js';
 import { getChannelsWithDescriptions, createDiscordClient, initDatabase, getChannelDirectory, startDiscordBot, initializeOpencodeForDirectory, ensureKimakiCategory, createProjectChannels, } from './discord-bot.js';
 import { getBotToken, setBotToken, setChannelDirectory, findChannelsByDirectory, findChannelByAppId, getThreadSession, getThreadIdBySessionId, getPrisma, } from './database.js';
+import { ShareMarkdown } from './markdown.js';
 import { formatWorktreeName } from './commands/worktree.js';
 import { WORKTREE_PREFIX } from './commands/merge-worktree.js';
 import yaml from 'js-yaml';
@@ -235,11 +236,11 @@ async function registerCommands({ token, appId, userCommands = [], agents = [],
             .toJSON(),
         new SlashCommandBuilder()
             .setName('add-project')
-            .setDescription('Create Discord channels for a project. Use `npx kimaki add-project` for unlisted projects')
+            .setDescription('Create Discord channels for a project. Use `npx kimaki project add` for unlisted projects')
             .addStringOption((option) => {
             option
                 .setName('project')
-                .setDescription('Select a project. Use `npx kimaki add-project` if not listed')
+                .setDescription('Recent OpenCode projects. Use `npx kimaki project add` if not listed')
                 .setRequired(true)
                 .setAutocomplete(true);
             return option;
@@ -1289,7 +1290,7 @@ cli
     }
 });
 cli
-    .command('project add [directory]', 'Create Discord channels for a project directory (e.g. ./folder)')
+    .command('project add [directory]', 'Create Discord channels for a project directory (replaces legacy add-project)')
     .alias('add-project')
     .option('-g, --guild <guildId>', 'Discord guild/server ID (auto-detects if bot is in only one server)')
     .option('-a, --app-id <appId>', 'Bot application ID (reads from database if available)')
@@ -1616,5 +1617,87 @@ cli
         process.exit(EXIT_NO_RESTART);
     }
 });
+cli
+    .command('session list', 'List all OpenCode sessions, marking which were started via Kimaki')
+    .option('--project <path>', 'Project directory to list sessions for (defaults to cwd)')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+    try {
+        const projectDirectory = path.resolve(options.project || '.');
+        await initDatabase();
+        cliLogger.log('Connecting to OpenCode server...');
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            cliLogger.error('Failed to connect to OpenCode:', getClient.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const sessionsResponse = await getClient().session.list();
+        const sessions = sessionsResponse.data || [];
+        if (sessions.length === 0) {
+            cliLogger.log('No sessions found');
+            process.exit(0);
+        }
+        // Look up which sessions were started via kimaki (have a thread mapping)
+        const prisma = await getPrisma();
+        const threadSessions = await prisma.thread_sessions.findMany({
+            select: { thread_id: true, session_id: true },
+        });
+        const sessionToThread = new Map(threadSessions
+            .filter((row) => row.session_id !== '')
+            .map((row) => [row.session_id, row.thread_id]));
+        if (options.json) {
+            const output = sessions.map((session) => ({
+                id: session.id,
+                title: session.title || 'Untitled Session',
+                directory: session.directory,
+                updated: new Date(session.time.updated).toISOString(),
+                source: sessionToThread.has(session.id) ? 'kimaki' : 'opencode',
+                threadId: sessionToThread.get(session.id) || null,
+            }));
+            console.log(JSON.stringify(output, null, 2));
+            process.exit(0);
+        }
+        for (const session of sessions) {
+            const threadId = sessionToThread.get(session.id);
+            const source = threadId ? '(kimaki)' : '(opencode)';
+            const updatedAt = new Date(session.time.updated).toISOString();
+            const threadInfo = threadId ? ` | thread: ${threadId}` : '';
+            console.log(`${session.id} | ${session.title || 'Untitled Session'} | ${session.directory} | ${updatedAt} | ${source}${threadInfo}`);
+        }
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('session read <sessionId>', 'Read a session conversation as markdown (pipe to file to grep)')
+    .option('--project <path>', 'Project directory (defaults to cwd)')
+    .action(async (sessionId, options) => {
+    try {
+        const projectDirectory = path.resolve(options.project || '.');
+        await initDatabase();
+        cliLogger.log('Connecting to OpenCode server...');
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        if (getClient instanceof Error) {
+            cliLogger.error('Failed to connect to OpenCode:', getClient.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        const markdown = new ShareMarkdown(getClient());
+        const result = await markdown.generate({ sessionID: sessionId });
+        if (result instanceof Error) {
+            cliLogger.error(result.message);
+            process.exit(EXIT_NO_RESTART);
+        }
+        // Print to stdout so it can be piped: kimaki session read <id> > ./tmp/session.md
+        process.stdout.write(result);
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
 cli.help();
 cli.parse();

package/dist/discord-utils.js

@@ -1,10 +1,10 @@
 // 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 } from 'discord.js';
+import { ChannelType, MessageFlags } from 'discord.js';
 import { REST, Routes } from 'discord.js';
 import { Lexer } from 'marked';
-import { formatMarkdownTables } from './format-tables.js';
+import { splitTablesFromMarkdown } from './format-tables.js';
 import { getChannelDirectory } from './database.js';
 import { limitHeadingDepth } from './limit-heading-depth.js';
 import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
@@ -264,27 +264,49 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
 }
 export async function sendThreadMessage(thread, content, options) {
     const MAX_LENGTH = 2000;
-    content = formatMarkdownTables(content);
-    content = unnestCodeBlocksFromLists(content);
-    content = limitHeadingDepth(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`);
-    }
+    // Split content into text and CV2 component segments (tables → Container components)
+    const segments = splitTablesFromMarkdown(content);
+    const baseFlags = options?.flags ?? SILENT_MESSAGE_FLAGS;
     let firstMessage;
-    for (let i = 0; i < chunks.length; i++) {
-        const chunk = chunks[i];
-        if (!chunk) {
+    for (const segment of segments) {
+        if (segment.type === 'components') {
+            const message = await thread.send({
+                components: segment.components,
+                flags: MessageFlags.IsComponentsV2 | baseFlags,
+            });
+            if (!firstMessage) {
+                firstMessage = message;
+            }
             continue;
         }
-        const message = await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
-        if (i === 0) {
-            firstMessage = message;
+        // Apply text transformations to text segments
+        let text = segment.text;
+        text = unnestCodeBlocksFromLists(text);
+        text = limitHeadingDepth(text);
+        text = escapeBackticksInCodeBlocks(text);
+        if (!text.trim()) {
+            continue;
+        }
+        // If custom flags provided, send as single message (no chunking)
+        if (options?.flags !== undefined) {
+            const message = await thread.send({ content: text, flags: options.flags });
+            if (!firstMessage) {
+                firstMessage = message;
+            }
+            continue;
+        }
+        const chunks = splitMarkdownForDiscord({ content: text, maxLength: MAX_LENGTH });
+        if (chunks.length > 1) {
+            discordLogger.log(`MESSAGE: Splitting ${text.length} chars into ${chunks.length} messages`);
+        }
+        for (const chunk of chunks) {
+            if (!chunk) {
+                continue;
+            }
+            const message = await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS });
+            if (!firstMessage) {
+                firstMessage = message;
+            }
         }
     }
     return firstMessage;

package/dist/format-tables.js

@@ -1,22 +1,50 @@
-// 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.
+// 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';
-export function formatMarkdownTables(markdown) {
+import { SeparatorSpacingSize, } from 'discord.js';
+// Max 40 components per message (nested components count toward the limit).
+// Each container uses: 1 (container) + M (TextDisplays) + M-1 (separators) = 2M children.
+// So max rows per container = floor((40 - 1) / 2) = 19.
+const MAX_COMPONENTS = 40;
+const MAX_ROWS_PER_CONTAINER = Math.floor((MAX_COMPONENTS - 1) / 2);
+/**
+ * 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) {
     const lexer = new Lexer();
     const tokens = lexer.lex(markdown);
-    let result = '';
+    const segments = [];
+    let textBuffer = '';
     for (const token of tokens) {
         if (token.type === 'table') {
-            result += formatTableToken(token);
+            if (textBuffer.trim()) {
+                segments.push({ type: 'text', text: textBuffer });
+                textBuffer = '';
+            }
+            const componentSegments = buildTableComponents(token);
+            segments.push(...componentSegments);
         }
         else {
-            result += token.raw;
+            textBuffer += token.raw;
         }
     }
-    return result;
+    if (textBuffer.trim()) {
+        segments.push({ type: 'text', text: textBuffer });
+    }
+    return segments;
 }
-function formatTableToken(table) {
+/**
+ * Build CV2 components for a table. Each data row becomes a single TextDisplay
+ * with all key-value pairs joined by newlines (header bold as key). Separator
+ * dividers are placed between row groups.
+ * Large tables are split into multiple component segments, each containing a
+ * Container with up to MAX_ROWS_PER_CONTAINER rows.
+ */
+export function buildTableComponents(table) {
     const headers = table.header.map((cell) => {
         return extractCellText(cell.tokens);
     });
@@ -25,14 +53,30 @@ function formatTableToken(table) {
             return extractCellText(cell.tokens);
         });
     });
-    const columnWidths = calculateColumnWidths(headers, rows);
-    const lines = [];
-    lines.push(formatRow(headers, columnWidths));
-    lines.push(formatSeparator(columnWidths));
-    for (const row of rows) {
-        lines.push(formatRow(row, columnWidths));
+    // Split rows into chunks that fit within the component limit
+    const chunks = [];
+    for (let i = 0; i < rows.length; i += MAX_ROWS_PER_CONTAINER) {
+        chunks.push(rows.slice(i, i + MAX_ROWS_PER_CONTAINER));
     }
-    return '```\n' + lines.join('\n') + '\n```\n';
+    return chunks.map((chunkRows) => {
+        const children = [];
+        for (let i = 0; i < chunkRows.length; i++) {
+            if (i > 0) {
+                children.push({ type: 14, divider: true, spacing: SeparatorSpacingSize.Small });
+            }
+            const row = chunkRows[i];
+            const lines = headers.map((key, j) => {
+                const value = row[j] || '';
+                return `**${key}** ${value}`;
+            });
+            children.push({ type: 10, content: lines.join('\n') });
+        }
+        const container = {
+            type: 17,
+            components: children,
+        };
+        return { type: 'components', components: [container] };
+    });
 }
 function extractCellText(tokens) {
     const parts = [];
@@ -69,28 +113,3 @@ function extractTokenText(token) {
         }
     }
 }
-function calculateColumnWidths(headers, rows) {
-    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, widths) {
-    const paddedCells = cells.map((cell, i) => {
-        return cell.padEnd(widths[i] ?? 0);
-    });
-    return paddedCells.join(' ');
-}
-function formatSeparator(widths) {
-    return widths
-        .map((w) => {
-        return '-'.repeat(w);
-    })
-        .join(' ');
-}