shuvmaki 0.4.26

package/dist/commands/queue.js

@@ -0,0 +1,129 @@
+// Queue commands - /queue, /clear-queue
+import { ChannelType } from 'discord.js';
+import { getDatabase } from '../database.js';
+import { resolveTextChannel, getKimakiMetadata, sendThreadMessage, SILENT_MESSAGE_FLAGS, } from '../discord-utils.js';
+import { handleOpencodeSession, abortControllers, addToQueue, getQueueLength, clearQueue, } from '../session-handler.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('QUEUE');
+export async function handleQueueCommand({ command, }) {
+    const message = command.options.getString('message', true);
+    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 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. Send a message directly instead.',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    // Check if there's an active request running
+    const hasActiveRequest = abortControllers.has(row.session_id);
+    if (!hasActiveRequest) {
+        // No active request, send immediately
+        const textChannel = await resolveTextChannel(channel);
+        const { projectDirectory } = getKimakiMetadata(textChannel);
+        if (!projectDirectory) {
+            await command.reply({
+                content: 'Could not determine project directory',
+                ephemeral: true,
+                flags: SILENT_MESSAGE_FLAGS,
+            });
+            return;
+        }
+        await command.reply({
+            content: `» **${command.user.displayName}:** ${message.slice(0, 100)}${message.length > 100 ? '...' : ''}`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`[QUEUE] No active request, sending immediately in thread ${channel.id}`);
+        handleOpencodeSession({
+            prompt: message,
+            thread: channel,
+            projectDirectory,
+            channelId: textChannel?.id || channel.id,
+        }).catch(async (e) => {
+            logger.error(`[QUEUE] Failed to send message:`, e);
+            const errorMsg = e instanceof Error ? e.message : String(e);
+            await sendThreadMessage(channel, `✗ Failed: ${errorMsg.slice(0, 200)}`);
+        });
+        return;
+    }
+    // Add to queue
+    const queuePosition = addToQueue({
+        threadId: channel.id,
+        message: {
+            prompt: message,
+            userId: command.user.id,
+            username: command.user.displayName,
+            queuedAt: Date.now(),
+        },
+    });
+    await command.reply({
+        content: `✅ Message queued (position: ${queuePosition}). Will be sent after current response.`,
+        ephemeral: true,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    logger.log(`[QUEUE] User ${command.user.displayName} queued message in thread ${channel.id}`);
+}
+export async function handleClearQueueCommand({ 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',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    const queueLength = getQueueLength(channel.id);
+    if (queueLength === 0) {
+        await command.reply({
+            content: 'No messages in queue',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    clearQueue(channel.id);
+    await command.reply({
+        content: `🗑 Cleared ${queueLength} queued message${queueLength > 1 ? 's' : ''}`,
+        flags: SILENT_MESSAGE_FLAGS,
+    });
+    logger.log(`[QUEUE] User ${command.user.displayName} cleared queue in thread ${channel.id}`);
+}

package/dist/commands/resume.js

@@ -0,0 +1,145 @@
+// /resume command - Resume an existing OpenCode session.
+import { ChannelType, ThreadAutoArchiveDuration, } from 'discord.js';
+import fs from 'node:fs';
+import { getDatabase } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { sendThreadMessage, resolveTextChannel, getKimakiMetadata, } from '../discord-utils.js';
+import { extractTagsArrays } from '../xml.js';
+import { collectLastAssistantParts } from '../message-formatting.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('RESUME');
+export async function handleResumeCommand({ command, appId, }) {
+    await command.deferReply({ ephemeral: false });
+    const sessionId = command.options.getString('session', true);
+    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 sessionResponse = await getClient().session.get({
+            path: { id: sessionId },
+        });
+        if (!sessionResponse.data) {
+            await command.editReply('Session not found');
+            return;
+        }
+        const sessionTitle = sessionResponse.data.title;
+        const thread = await textChannel.threads.create({
+            name: `Resume: ${sessionTitle}`.slice(0, 100),
+            autoArchiveDuration: ThreadAutoArchiveDuration.OneDay,
+            reason: `Resuming session ${sessionId}`,
+        });
+        getDatabase()
+            .prepare('INSERT OR REPLACE INTO thread_sessions (thread_id, session_id) VALUES (?, ?)')
+            .run(thread.id, sessionId);
+        logger.log(`[RESUME] Created thread ${thread.id} for session ${sessionId}`);
+        const messagesResponse = await getClient().session.messages({
+            path: { id: sessionId },
+        });
+        if (!messagesResponse.data) {
+            throw new Error('Failed to fetch session messages');
+        }
+        const messages = messagesResponse.data;
+        await command.editReply(`Resumed session "${sessionTitle}" in ${thread.toString()}`);
+        await sendThreadMessage(thread, `📂 **Resumed session:** ${sessionTitle}\n📅 **Created:** ${new Date(sessionResponse.data.time.created).toLocaleString()}\n\n*Loading ${messages.length} messages...*`);
+        const { partIds, content, skippedCount } = collectLastAssistantParts({
+            messages,
+        });
+        if (skippedCount > 0) {
+            await sendThreadMessage(thread, `*Skipped ${skippedCount} older assistant parts...*`);
+        }
+        if (content.trim()) {
+            const discordMessage = await sendThreadMessage(thread, content);
+            const stmt = getDatabase().prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)');
+            const transaction = getDatabase().transaction((ids) => {
+                for (const partId of ids) {
+                    stmt.run(partId, discordMessage.id, thread.id);
+                }
+            });
+            transaction(partIds);
+        }
+        const messageCount = messages.length;
+        await sendThreadMessage(thread, `✅ **Session resumed!** Loaded ${messageCount} messages.\n\nYou can now continue the conversation by sending messages in this thread.`);
+    }
+    catch (error) {
+        logger.error('[RESUME] Error:', error);
+        await command.editReply(`Failed to resume session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleResumeAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    let projectDirectory;
+    if (interaction.channel) {
+        const textChannel = await resolveTextChannel(interaction.channel);
+        if (textChannel) {
+            const { projectDirectory: directory, channelAppId } = getKimakiMetadata(textChannel);
+            if (channelAppId && channelAppId !== appId) {
+                await interaction.respond([]);
+                return;
+            }
+            projectDirectory = directory;
+        }
+    }
+    if (!projectDirectory) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        const sessionsResponse = await getClient().session.list();
+        if (!sessionsResponse.data) {
+            await interaction.respond([]);
+            return;
+        }
+        const existingSessionIds = new Set(getDatabase()
+            .prepare('SELECT session_id FROM thread_sessions')
+            .all().map((row) => row.session_id));
+        const sessions = sessionsResponse.data
+            .filter((session) => !existingSessionIds.has(session.id))
+            .filter((session) => session.title.toLowerCase().includes(focusedValue.toLowerCase()))
+            .slice(0, 25)
+            .map((session) => {
+            const dateStr = new Date(session.time.updated).toLocaleString();
+            const suffix = ` (${dateStr})`;
+            const maxTitleLength = 100 - suffix.length;
+            let title = session.title;
+            if (title.length > maxTitleLength) {
+                title = title.slice(0, Math.max(0, maxTitleLength - 1)) + '…';
+            }
+            return {
+                name: `${title}${suffix}`,
+                value: session.id,
+            };
+        });
+        await interaction.respond(sessions);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching sessions:', error);
+        await interaction.respond([]);
+    }
+}

package/dist/commands/session.js

@@ -0,0 +1,142 @@
+// /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 } 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()}`);
+        await handleOpencodeSession({
+            prompt: fullPrompt,
+            thread,
+            projectDirectory,
+            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'}`);
+    }
+}