kimaki 0.4.24 → 0.4.25

package/dist/commands/session.js

@@ -0,0 +1,144 @@
+// /session command - Start a new OpenCode session.
+import { ChannelType } from 'discord.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { extractTagsArrays } from '../xml.js';
+import { handleOpencodeSession, parseSlashCommand } from '../session-handler.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('SESSION');
+export async function handleSessionCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const prompt = command.options.getString('prompt', true);
+    const filesString = command.options.getString('files') || '';
+    const channel = command.channel;
+    if (!channel || channel.type !== ChannelType.GuildText) {
+        await command.editReply('This command can only be used in text channels');
+        return;
+    }
+    const textChannel = channel;
+    let projectDirectory;
+    let channelAppId;
+    if (textChannel.topic) {
+        const extracted = extractTagsArrays({
+            xml: textChannel.topic,
+            tags: ['kimaki.directory', 'kimaki.app'],
+        });
+        projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+        channelAppId = extracted['kimaki.app']?.[0]?.trim();
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await command.editReply('This channel is not configured for this bot');
+        return;
+    }
+    if (!projectDirectory) {
+        await command.editReply('This channel is not configured with a project directory');
+        return;
+    }
+    if (!fs.existsSync(projectDirectory)) {
+        await command.editReply(`Directory does not exist: ${projectDirectory}`);
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        const files = filesString
+            .split(',')
+            .map((f) => f.trim())
+            .filter((f) => f);
+        let fullPrompt = prompt;
+        if (files.length > 0) {
+            fullPrompt = `${prompt}\n\n@${files.join(' @')}`;
+        }
+        const starterMessage = await textChannel.send({
+            content: `🚀 **Starting OpenCode session**\n📝 ${prompt.slice(0, 200)}${prompt.length > 200 ? '…' : ''}${files.length > 0 ? `\n📎 Files: ${files.join(', ')}` : ''}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        const thread = await starterMessage.startThread({
+            name: prompt.slice(0, 100),
+            autoArchiveDuration: 1440,
+            reason: 'OpenCode session',
+        });
+        await command.editReply(`Created new session in ${thread.toString()}`);
+        const parsedCommand = parseSlashCommand(fullPrompt);
+        await handleOpencodeSession({
+            prompt: fullPrompt,
+            thread,
+            projectDirectory,
+            parsedCommand,
+            channelId: textChannel.id,
+        });
+    }
+    catch (error) {
+        logger.error('[SESSION] Error:', error);
+        await command.editReply(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleSessionAutocomplete({ interaction, appId, }) {
+    const focusedOption = interaction.options.getFocused(true);
+    if (focusedOption.name !== 'files') {
+        return;
+    }
+    const focusedValue = focusedOption.value;
+    const parts = focusedValue.split(',');
+    const previousFiles = parts
+        .slice(0, -1)
+        .map((f) => f.trim())
+        .filter((f) => f);
+    const currentQuery = (parts[parts.length - 1] || '').trim();
+    let projectDirectory;
+    if (interaction.channel) {
+        const channel = interaction.channel;
+        if (channel.type === ChannelType.GuildText) {
+            const textChannel = channel;
+            if (textChannel.topic) {
+                const extracted = extractTagsArrays({
+                    xml: textChannel.topic,
+                    tags: ['kimaki.directory', 'kimaki.app'],
+                });
+                const channelAppId = extracted['kimaki.app']?.[0]?.trim();
+                if (channelAppId && channelAppId !== appId) {
+                    await interaction.respond([]);
+                    return;
+                }
+                projectDirectory = extracted['kimaki.directory']?.[0]?.trim();
+            }
+        }
+    }
+    if (!projectDirectory) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        const response = await getClient().find.files({
+            query: {
+                query: currentQuery || '',
+            },
+        });
+        const files = response.data || [];
+        const prefix = previousFiles.length > 0 ? previousFiles.join(', ') + ', ' : '';
+        const choices = files
+            .map((file) => {
+            const fullValue = prefix + file;
+            const allFiles = [...previousFiles, file];
+            const allBasenames = allFiles.map((f) => f.split('/').pop() || f);
+            let displayName = allBasenames.join(', ');
+            if (displayName.length > 100) {
+                displayName = '…' + displayName.slice(-97);
+            }
+            return {
+                name: displayName,
+                value: fullValue,
+            };
+        })
+            .filter((choice) => choice.value.length <= 100)
+            .slice(0, 25);
+        await interaction.respond(choices);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching files:', error);
+        await interaction.respond([]);
+    }
+}

package/dist/commands/share.js

@@ -0,0 +1,80 @@
+// /share command - Share the current session as a public URL.
+import { ChannelType } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('SHARE');
+export async function handleShareCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(channel);
+    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+    if (!directory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await command.reply({
+            content: 'No active session in this thread',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const sessionId = row.session_id;
+    try {
+        const getClient = await initializeOpencodeForDirectory(directory);
+        const response = await getClient().session.share({
+            path: { id: sessionId },
+        });
+        if (!response.data?.share?.url) {
+            await command.reply({
+                content: 'Failed to generate share URL',
+                ephemeral: true,
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            return;
+        }
+        await command.reply({
+            content: `🔗 **Session shared:** ${response.data.share.url}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`Session ${sessionId} shared: ${response.data.share.url}`);
+    }
+    catch (error) {
+        logger.error('[SHARE] Error:', error);
+        await command.reply({
+            content: `Failed to share session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+}

package/dist/commands/types.js

@@ -0,0 +1,2 @@
+// Shared types for command handlers.
+export {};

package/dist/commands/undo-redo.js

@@ -0,0 +1,161 @@
+// Undo/Redo commands - /undo, /redo
+import { ChannelType } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('UNDO-REDO');
+export async function handleUndoCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(channel);
+    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+    if (!directory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await command.reply({
+            content: 'No active session in this thread',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const sessionId = row.session_id;
+    try {
+        await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+        const getClient = await initializeOpencodeForDirectory(directory);
+        // Fetch messages to find the last assistant message
+        const messagesResponse = await getClient().session.messages({
+            path: { id: sessionId },
+        });
+        if (!messagesResponse.data || messagesResponse.data.length === 0) {
+            await command.editReply('No messages to undo');
+            return;
+        }
+        // Find the last assistant message
+        const lastAssistantMessage = [...messagesResponse.data]
+            .reverse()
+            .find((m) => m.info.role === 'assistant');
+        if (!lastAssistantMessage) {
+            await command.editReply('No assistant message to undo');
+            return;
+        }
+        const response = await getClient().session.revert({
+            path: { id: sessionId },
+            body: { messageID: lastAssistantMessage.info.id },
+        });
+        if (response.error) {
+            await command.editReply(`Failed to undo: ${JSON.stringify(response.error)}`);
+            return;
+        }
+        const diffInfo = response.data?.revert?.diff
+            ? `\n\`\`\`diff\n${response.data.revert.diff.slice(0, 1500)}\n\`\`\``
+            : '';
+        await command.editReply(`⏪ **Undone** - reverted last assistant message${diffInfo}`);
+        logger.log(`Session ${sessionId} reverted message ${lastAssistantMessage.info.id}`);
+    }
+    catch (error) {
+        logger.error('[UNDO] Error:', error);
+        await command.editReply(`Failed to undo: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleRedoCommand({ command, }) {
+    const channel = command.channel;
+    if (!channel) {
+        await command.reply({
+            content: 'This command can only be used in a channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    if (!isThread) {
+        await command.reply({
+            content: 'This command can only be used in a thread with an active session',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const textChannel = await resolveTextChannel(channel);
+    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+    if (!directory) {
+        await command.reply({
+            content: 'Could not determine project directory for this channel',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const row = getDatabase()
+        .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+        .get(channel.id);
+    if (!row?.session_id) {
+        await command.reply({
+            content: 'No active session in this thread',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const sessionId = row.session_id;
+    try {
+        await command.deferReply({ flags: SILENT_MESSAGE_FLAGS });
+        const getClient = await initializeOpencodeForDirectory(directory);
+        // Check if session has reverted state
+        const sessionResponse = await getClient().session.get({
+            path: { id: sessionId },
+        });
+        if (!sessionResponse.data?.revert) {
+            await command.editReply('Nothing to redo - no previous undo found');
+            return;
+        }
+        const response = await getClient().session.unrevert({
+            path: { id: sessionId },
+        });
+        if (response.error) {
+            await command.editReply(`Failed to redo: ${JSON.stringify(response.error)}`);
+            return;
+        }
+        await command.editReply(`⏩ **Restored** - session back to previous state`);
+        logger.log(`Session ${sessionId} unrevert completed`);
+    }
+    catch (error) {
+        logger.error('[REDO] Error:', error);
+        await command.editReply(`Failed to redo: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/database.js

@@ -1,3 +1,6 @@
+// SQLite database manager for persistent bot state.
+// Stores thread-session mappings, bot tokens, channel directories,
+// API keys, and model preferences in ~/.kimaki/discord-sessions.db.
 import Database from 'better-sqlite3';
 import fs from 'node:fs';
 import os from 'node:os';

package/dist/discord-bot.js

@@ -1,3 +1,6 @@
+// Core Discord bot module that handles message events and bot lifecycle.
+// Bridges Discord messages to OpenCode sessions, manages voice connections,
+// and orchestrates the main event loop for the Kimaki bot.
 import { getDatabase, closeDatabase } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js';
 import { escapeBackticksInCodeBlocks, splitMarkdownForDiscord, SILENT_MESSAGE_FLAGS, } from './discord-utils.js';

package/dist/discord-utils.js

@@ -1,3 +1,6 @@
+// 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 { Lexer } from 'marked';
 import { extractTagsArrays } from './xml.js';
@@ -5,6 +8,8 @@ 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) {
     const lexer = new Lexer();
     const tokens = lexer.lex(markdown);
@@ -91,10 +96,14 @@ export function splitMarkdownForDiscord({ content, maxLength, }) {
     }
     return chunks;
 }
-export async function sendThreadMessage(thread, content) {
+export async function sendThreadMessage(thread, content, options) {
     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`);

package/dist/format-tables.js

@@ -1,3 +1,6 @@
+// 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.
 import { Lexer } from 'marked';
 export function formatMarkdownTables(markdown) {
     const lexer = new Lexer();

package/dist/genai-worker-wrapper.js

@@ -1,3 +1,6 @@
+// Main thread interface for the GenAI worker.
+// Spawns and manages the worker thread, handling message passing for
+// audio input/output, tool call completions, and graceful shutdown.
 import { Worker } from 'node:worker_threads';
 import { createLogger } from './logger.js';
 const genaiWorkerLogger = createLogger('GENAI WORKER');

package/dist/genai-worker.js

@@ -1,3 +1,6 @@
+// Worker thread for GenAI voice processing.
+// Runs in a separate thread to handle audio encoding/decoding without blocking.
+// Resamples 24kHz GenAI output to 48kHz stereo Opus packets for Discord.
 import { parentPort, threadId } from 'node:worker_threads';
 import { createWriteStream } from 'node:fs';
 import { mkdir } from 'node:fs/promises';

package/dist/genai.js

@@ -1,3 +1,6 @@
+// Google GenAI Live session manager for real-time voice interactions.
+// Establishes bidirectional audio streaming with Gemini, handles tool calls,
+// and manages the assistant's audio output for Discord voice channels.
 import { GoogleGenAI, LiveServerMessage, MediaResolution, Modality, Session, } from '@google/genai';
 import { writeFile } from 'fs';
 import { createLogger } from './logger.js';