kimaki 0.4.21 → 0.4.23

package/dist/discord-utils.js

@@ -0,0 +1,151 @@
+import { ChannelType, } 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;
+export function escapeBackticksInCodeBlocks(markdown) {
+    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;
+}
+export function splitMarkdownForDiscord({ content, maxLength, }) {
+    if (content.length <= maxLength) {
+        return [content];
+    }
+    const lexer = new Lexer();
+    const tokens = lexer.lex(content);
+    const lines = [];
+    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 = [];
+    let currentChunk = '';
+    let currentLang = null;
+    for (const line of lines) {
+        const wouldExceed = currentChunk.length + line.text.length > maxLength;
+        if (wouldExceed && 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 += 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, content) {
+    const MAX_LENGTH = 2000;
+    content = formatMarkdownTables(content);
+    content = escapeBackticksInCodeBlocks(content);
+    const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH });
+    if (chunks.length > 1) {
+        discordLogger.log(`MESSAGE: Splitting ${content.length} chars into ${chunks.length} messages`);
+    }
+    let firstMessage;
+    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) {
+    if (!channel) {
+        return null;
+    }
+    if (channel.type === ChannelType.GuildText) {
+        return channel;
+    }
+    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;
+            }
+        }
+    }
+    return null;
+}
+export function escapeDiscordFormatting(text) {
+    return text
+        .replace(/```/g, '\\`\\`\\`')
+        .replace(/````/g, '\\`\\`\\`\\`');
+}
+export function getKimakiMetadata(textChannel) {
+    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/dist/discordBot.js

@@ -16,6 +16,7 @@ import * as prism from 'prism-media';
 import dedent from 'string-dedent';
 import { transcribeAudio } from './voice.js';
 import { extractTagsArrays, extractNonXmlContent } from './xml.js';
+import { formatMarkdownTables } from './format-tables.js';
 import prettyMilliseconds from 'pretty-ms';
 import { createLogger } from './logger.js';
 import { isAbortError } from './utils.js';
@@ -564,6 +565,7 @@ async function getOpenPort() {
  */
 async function sendThreadMessage(thread, content) {
     const MAX_LENGTH = 2000;
+    content = formatMarkdownTables(content);
     content = escapeBackticksInCodeBlocks(content);
     const chunks = splitMarkdownForDiscord({ content, maxLength: MAX_LENGTH });
     if (chunks.length > 1) {
@@ -818,7 +820,7 @@ function escapeInlineCode(text) {
         .replace(/(?<!\\)`(?!`)/g, '\\`') // Single backticks (not already escaped or part of double/triple)
         .replace(/\|\|/g, '\\|\\|'); // Double pipes (spoiler syntax)
 }
-function resolveTextChannel(channel) {
+async function resolveTextChannel(channel) {
     if (!channel) {
         return null;
     }
@@ -828,9 +830,12 @@ function resolveTextChannel(channel) {
     if (channel.type === ChannelType.PublicThread ||
         channel.type === ChannelType.PrivateThread ||
         channel.type === ChannelType.AnnouncementThread) {
-        const parent = channel.parent;
-        if (parent?.type === ChannelType.GuildText) {
-            return parent;
+        const parentId = channel.parentId;
+        if (parentId) {
+            const parent = await channel.guild.channels.fetch(parentId);
+            if (parent?.type === ChannelType.GuildText) {
+                return parent;
+            }
         }
     }
     return null;
@@ -1003,9 +1008,17 @@ function getToolSummaryText(part) {
         const pattern = part.state.input?.pattern || '';
         return pattern ? `*${pattern}*` : '';
     }
-    if (part.tool === 'bash' || part.tool === 'task' || part.tool === 'todoread' || part.tool === 'todowrite') {
+    if (part.tool === 'bash' || part.tool === 'todoread' || part.tool === 'todowrite') {
         return '';
     }
+    if (part.tool === 'task') {
+        const description = part.state.input?.description || '';
+        return description ? `_${description}_` : '';
+    }
+    if (part.tool === 'skill') {
+        const name = part.state.input?.name || '';
+        return name ? `_${name}_` : '';
+    }
     if (!part.state.input)
         return '';
     const inputFields = Object.entries(part.state.input)
@@ -1025,20 +1038,13 @@ function formatTodoList(part) {
     if (part.type !== 'tool' || part.tool !== 'todowrite')
         return '';
     const todos = part.state.input?.todos || [];
-    if (todos.length === 0)
+    const activeIndex = todos.findIndex((todo) => {
+        return todo.status === 'in_progress';
+    });
+    const activeTodo = todos[activeIndex];
+    if (activeIndex === -1 || !activeTodo)
         return '';
-    return todos
-        .map((todo, i) => {
-        const num = `${i + 1}.`;
-        if (todo.status === 'in_progress') {
-            return `${num} **${todo.content}**`;
-        }
-        if (todo.status === 'completed' || todo.status === 'cancelled') {
-            return `${num} ~~${todo.content}~~`;
-        }
-        return `${num} ${todo.content}`;
-    })
-        .join('\n');
+    return `${activeIndex + 1}. **${activeTodo.content}**`;
 }
 function formatPart(part) {
     if (part.type === 'text') {
@@ -1078,9 +1084,9 @@ function formatPart(part) {
             const command = part.state.input?.command || '';
             const description = part.state.input?.description || '';
             const isSingleLine = !command.includes('\n');
-            const hasBackticks = command.includes('`');
-            if (isSingleLine && !hasBackticks && command.length <= 50) {
-                toolTitle = `\`${command}\``;
+            const hasUnderscores = command.includes('_');
+            if (isSingleLine && !hasUnderscores && command.length <= 50) {
+                toolTitle = `_${command}_`;
             }
             else if (description) {
                 toolTitle = `_${description}_`;
@@ -1199,6 +1205,8 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
     let usedModel;
     let usedProviderID;
     let tokensUsedInSession = 0;
+    let lastDisplayedContextPercentage = 0;
+    let modelContextLimit;
     let typingInterval = null;
     function startTyping() {
         if (abortController.signal.aborted) {
@@ -1272,6 +1280,29 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                         assistantMessageId = msg.id;
                         usedModel = msg.modelID;
                         usedProviderID = msg.providerID;
+                        if (tokensUsedInSession > 0 && usedProviderID && usedModel) {
+                            if (!modelContextLimit) {
+                                try {
+                                    const providersResponse = await getClient().provider.list({ query: { directory } });
+                                    const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
+                                    const model = provider?.models?.[usedModel];
+                                    if (model?.limit?.context) {
+                                        modelContextLimit = model.limit.context;
+                                    }
+                                }
+                                catch (e) {
+                                    sessionLogger.error('Failed to fetch provider info for context limit:', e);
+                                }
+                            }
+                            if (modelContextLimit) {
+                                const currentPercentage = Math.floor((tokensUsedInSession / modelContextLimit) * 100);
+                                const thresholdCrossed = Math.floor(currentPercentage / 10) * 10;
+                                if (thresholdCrossed > lastDisplayedContextPercentage && thresholdCrossed >= 10) {
+                                    lastDisplayedContextPercentage = thresholdCrossed;
+                                    await sendThreadMessage(thread, `◼︎ context usage ${currentPercentage}%`);
+                                }
+                            }
+                        }
                     }
                 }
                 else if (event.type === 'message.part.updated') {
@@ -1774,9 +1805,8 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     const focusedValue = interaction.options.getFocused();
                     // Get the channel's project directory from its topic
                     let projectDirectory;
-                    if (interaction.channel &&
-                        interaction.channel.type === ChannelType.GuildText) {
-                        const textChannel = resolveTextChannel(interaction.channel);
+                    if (interaction.channel) {
+                        const textChannel = await resolveTextChannel(interaction.channel);
                         if (textChannel) {
                             const { projectDirectory: directory, channelAppId } = getKimakiMetadata(textChannel);
                             if (channelAppId && channelAppId !== currentAppId) {
@@ -1839,9 +1869,8 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         const currentQuery = (parts[parts.length - 1] || '').trim();
                         // Get the channel's project directory from its topic
                         let projectDirectory;
-                        if (interaction.channel &&
-                            interaction.channel.type === ChannelType.GuildText) {
-                            const textChannel = resolveTextChannel(interaction.channel);
+                        if (interaction.channel) {
+                            const textChannel = await resolveTextChannel(interaction.channel);
                             if (textChannel) {
                                 const { projectDirectory: directory, channelAppId } = getKimakiMetadata(textChannel);
                                 if (channelAppId && channelAppId !== currentAppId) {
@@ -2103,7 +2132,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         if (partsToRender.length > 0) {
                             const combinedContent = partsToRender
                                 .map((p) => p.content)
-                                .join('\n\n');
+                                .join('\n');
                             const discordMessage = await sendThreadMessage(thread, combinedContent);
                             const stmt = getDatabase().prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)');
                             const transaction = getDatabase().transaction((parts) => {
@@ -2168,7 +2197,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         await command.editReply(`Failed to create channels: ${error instanceof Error ? error.message : 'Unknown error'}`);
                     }
                 }
-                else if (command.commandName === 'add-new-project') {
+                else if (command.commandName === 'create-new-project') {
                     await command.deferReply({ ephemeral: false });
                     const projectName = command.options.getString('name', true);
                     const guild = command.guild;
@@ -2364,7 +2393,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                         return;
                     }
-                    const textChannel = resolveTextChannel(channel);
+                    const textChannel = await resolveTextChannel(channel);
                     const { projectDirectory: directory } = getKimakiMetadata(textChannel);
                     if (!directory) {
                         await command.reply({
@@ -2426,7 +2455,7 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                         return;
                     }
-                    const textChannel = resolveTextChannel(channel);
+                    const textChannel = await resolveTextChannel(channel);
                     const { projectDirectory: directory } = getKimakiMetadata(textChannel);
                     if (!directory) {
                         await command.reply({

package/dist/escape-backticks.test.js

@@ -1,6 +1,6 @@
 import { test, expect } from 'vitest';
 import { Lexer } from 'marked';
-import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord } from './discordBot.js';
+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);

package/dist/fork.js

@@ -0,0 +1,163 @@
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
+import { getDatabase } from './database.js';
+import { initializeOpencodeForDirectory } from './opencode.js';
+import { resolveTextChannel, getKimakiMetadata, sendThreadMessage } from './discord-utils.js';
+import { createLogger } from './logger.js';
+const sessionLogger = createLogger('SESSION');
+const forkLogger = createLogger('FORK');
+export async function handleForkCommand(interaction) {
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await interaction.reply({
+            content: 'This command can only be used in a thread with an active session',
+            ephemeral: true,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(channel);
+    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+    if (!directory) {
+        await interaction.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+        });
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await interaction.reply({
+            content: 'No active session in this thread',
+            ephemeral: true,
+        });
+        return;
+    }
+    // Defer reply before API calls to avoid 3-second timeout
+    await interaction.deferReply({ ephemeral: true });
+    const sessionId = row.session_id;
+    try {
+        const getClient = await initializeOpencodeForDirectory(directory);
+        const messagesResponse = await getClient().session.messages({
+            path: { id: sessionId },
+        });
+        if (!messagesResponse.data) {
+            await interaction.editReply({
+                content: 'Failed to fetch session messages',
+            });
+            return;
+        }
+        const userMessages = messagesResponse.data.filter((m) => m.info.role === 'user');
+        if (userMessages.length === 0) {
+            await interaction.editReply({
+                content: 'No user messages found in this session',
+            });
+            return;
+        }
+        const recentMessages = userMessages.slice(-25);
+        const options = recentMessages.map((m, index) => {
+            const textPart = m.parts.find((p) => p.type === 'text');
+            const preview = textPart?.text?.slice(0, 80) || '(no text)';
+            const label = `${index + 1}. ${preview}${preview.length >= 80 ? '...' : ''}`;
+            return {
+                label: label.slice(0, 100),
+                value: m.info.id,
+                description: new Date(m.info.time.created).toLocaleString().slice(0, 50),
+            };
+        });
+        const encodedDir = Buffer.from(directory).toString('base64');
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`fork_select:${sessionId}:${encodedDir}`)
+            .setPlaceholder('Select a message to fork from')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder()
+            .addComponents(selectMenu);
+        await interaction.editReply({
+            content: '**Fork Session**\nSelect the user message to fork from. The forked session will continue as if you had not sent that message:',
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        forkLogger.error('Error loading messages:', error);
+        await interaction.editReply({
+            content: `Failed to load messages: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}
+export async function handleForkSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('fork_select:')) {
+        return;
+    }
+    const [, sessionId, encodedDir] = customId.split(':');
+    if (!sessionId || !encodedDir) {
+        await interaction.reply({
+            content: 'Invalid selection data',
+            ephemeral: true,
+        });
+        return;
+    }
+    const directory = Buffer.from(encodedDir, 'base64').toString('utf-8');
+    const selectedMessageId = interaction.values[0];
+    if (!selectedMessageId) {
+        await interaction.reply({
+            content: 'No message selected',
+            ephemeral: true,
+        });
+        return;
+    }
+    await interaction.deferReply({ ephemeral: false });
+    try {
+        const getClient = await initializeOpencodeForDirectory(directory);
+        const forkResponse = await getClient().session.fork({
+            path: { id: sessionId },
+            body: { messageID: selectedMessageId },
+        });
+        if (!forkResponse.data) {
+            await interaction.editReply('Failed to fork session');
+            return;
+        }
+        const forkedSession = forkResponse.data;
+        const parentChannel = interaction.channel;
+        if (!parentChannel || ![
+            ChannelType.PublicThread,
+            ChannelType.PrivateThread,
+            ChannelType.AnnouncementThread,
+        ].includes(parentChannel.type)) {
+            await interaction.editReply('Could not access parent channel');
+            return;
+        }
+        const textChannel = await resolveTextChannel(parentChannel);
+        if (!textChannel) {
+            await interaction.editReply('Could not resolve parent text channel');
+            return;
+        }
+        const thread = await textChannel.threads.create({
+            name: `Fork: ${forkedSession.title}`.slice(0, 100),
+            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+            reason: `Forked from session ${sessionId}`,
+        });
+        getDatabase()
+            .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
+            .run(thread.id, forkedSession.id);
+        sessionLogger.log(`Created forked session ${forkedSession.id} in thread ${thread.id}`);
+        await sendThreadMessage(thread, `**Forked session created!**\nFrom: \`${sessionId}\`\nNew session: \`${forkedSession.id}\`\n\nYou can now continue the conversation from this point.`);
+        await interaction.editReply(`Session forked! Continue in ${thread.toString()}`);
+    }
+    catch (error) {
+        forkLogger.error('Error forking session:', error);
+        await interaction.editReply(`Failed to fork session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/format-tables.js

@@ -0,0 +1,93 @@
+import { Lexer } from 'marked';
+export function formatMarkdownTables(markdown) {
+    const lexer = new Lexer();
+    const tokens = lexer.lex(markdown);
+    let result = '';
+    for (const token of tokens) {
+        if (token.type === 'table') {
+            result += formatTableToken(token);
+        }
+        else {
+            result += token.raw;
+        }
+    }
+    return result;
+}
+function formatTableToken(table) {
+    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 = [];
+    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) {
+    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 '';
+        }
+    }
+}
+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(' ');
+}