shuvmaki 0.4.26

package/dist/commands/fork.js

@@ -0,0 +1,186 @@
+// /fork command - Fork the session from a past user message.
+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 { collectLastAssistantParts } from '../message-formatting.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}\``);
+        // Fetch and display the last assistant messages from the forked session
+        const messagesResponse = await getClient().session.messages({
+            path: { id: forkedSession.id },
+        });
+        if (messagesResponse.data) {
+            const { partIds, content } = collectLastAssistantParts({
+                messages: messagesResponse.data,
+            });
+            if (content.trim()) {
+                const discordMessage = await sendThreadMessage(thread, content);
+                // Store part-message mappings for future reference
+                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);
+            }
+        }
+        await sendThreadMessage(thread, `You 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/commands/model.js

@@ -0,0 +1,313 @@
+// /model command - Set the preferred model for this channel or session.
+import { ChatInputCommandInteraction, StringSelectMenuInteraction, StringSelectMenuBuilder, ActionRowBuilder, ChannelType, } from 'discord.js';
+import crypto from 'node:crypto';
+import { getDatabase, setChannelModel, setSessionModel, runModelMigrations } from '../database.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { resolveTextChannel, getKimakiMetadata } from '../discord-utils.js';
+import { abortAndRetrySession } from '../session-handler.js';
+import { createLogger } from '../logger.js';
+const modelLogger = createLogger('MODEL');
+// Store context by hash to avoid customId length limits (Discord max: 100 chars)
+const pendingModelContexts = new Map();
+/**
+ * Handle the /model slash command.
+ * Shows a select menu with available providers.
+ */
+export async function handleModelCommand({ interaction, appId, }) {
+    modelLogger.log('[MODEL] handleModelCommand called');
+    // Defer reply immediately to avoid 3-second timeout
+    await interaction.deferReply({ ephemeral: true });
+    modelLogger.log('[MODEL] Deferred reply');
+    // Ensure migrations are run
+    runModelMigrations();
+    const channel = interaction.channel;
+    if (!channel) {
+        await interaction.editReply({
+            content: 'This command can only be used in a channel',
+        });
+        return;
+    }
+    // Determine if we're in a thread or text channel
+    const isThread = [
+        ChannelType.PublicThread,
+        ChannelType.PrivateThread,
+        ChannelType.AnnouncementThread,
+    ].includes(channel.type);
+    let projectDirectory;
+    let channelAppId;
+    let targetChannelId;
+    let sessionId;
+    if (isThread) {
+        const thread = channel;
+        const textChannel = await resolveTextChannel(thread);
+        const metadata = getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = textChannel?.id || channel.id;
+        // Get session ID for this thread
+        const row = getDatabase()
+            .prepare('SELECT session_id FROM thread_sessions WHERE thread_id = ?')
+            .get(thread.id);
+        sessionId = row?.session_id;
+    }
+    else if (channel.type === ChannelType.GuildText) {
+        const textChannel = channel;
+        const metadata = getKimakiMetadata(textChannel);
+        projectDirectory = metadata.projectDirectory;
+        channelAppId = metadata.channelAppId;
+        targetChannelId = channel.id;
+    }
+    else {
+        await interaction.editReply({
+            content: 'This command can only be used in text channels or threads',
+        });
+        return;
+    }
+    if (channelAppId && channelAppId !== appId) {
+        await interaction.editReply({
+            content: 'This channel is not configured for this bot',
+        });
+        return;
+    }
+    if (!projectDirectory) {
+        await interaction.editReply({
+            content: 'This channel is not configured with a project directory',
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(projectDirectory);
+        const providersResponse = await getClient().provider.list({
+            query: { directory: projectDirectory },
+        });
+        if (!providersResponse.data) {
+            await interaction.editReply({
+                content: 'Failed to fetch providers',
+            });
+            return;
+        }
+        const { all: allProviders, connected } = providersResponse.data;
+        // Filter to only connected providers (have credentials)
+        const availableProviders = allProviders.filter((p) => {
+            return connected.includes(p.id);
+        });
+        if (availableProviders.length === 0) {
+            await interaction.editReply({
+                content: 'No providers with credentials found. Use `/connect` in OpenCode TUI to add provider credentials.',
+            });
+            return;
+        }
+        // Store context with a short hash key to avoid customId length limits
+        const context = {
+            dir: projectDirectory,
+            channelId: targetChannelId,
+            sessionId: sessionId,
+            isThread: isThread,
+            thread: isThread ? channel : undefined,
+        };
+        const contextHash = crypto.randomBytes(8).toString('hex');
+        pendingModelContexts.set(contextHash, context);
+        const options = availableProviders.slice(0, 25).map((provider) => {
+            const modelCount = Object.keys(provider.models || {}).length;
+            return {
+                label: provider.name.slice(0, 100),
+                value: provider.id,
+                description: `${modelCount} model${modelCount !== 1 ? 's' : ''} available`.slice(0, 100),
+            };
+        });
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`model_provider:${contextHash}`)
+            .setPlaceholder('Select a provider')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: '**Set Model Preference**\nSelect a provider:',
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        modelLogger.error('Error loading providers:', error);
+        await interaction.editReply({
+            content: `Failed to load providers: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        });
+    }
+}
+/**
+ * Handle the provider select menu interaction.
+ * Shows a second select menu with models for the chosen provider.
+ */
+export async function handleProviderSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('model_provider:')) {
+        return;
+    }
+    // Defer update immediately to avoid timeout
+    await interaction.deferUpdate();
+    const contextHash = customId.replace('model_provider:', '');
+    const context = pendingModelContexts.get(contextHash);
+    if (!context) {
+        await interaction.editReply({
+            content: 'Selection expired. Please run /model again.',
+            components: [],
+        });
+        return;
+    }
+    const selectedProviderId = interaction.values[0];
+    if (!selectedProviderId) {
+        await interaction.editReply({
+            content: 'No provider selected',
+            components: [],
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(context.dir);
+        const providersResponse = await getClient().provider.list({
+            query: { directory: context.dir },
+        });
+        if (!providersResponse.data) {
+            await interaction.editReply({
+                content: 'Failed to fetch providers',
+                components: [],
+            });
+            return;
+        }
+        const provider = providersResponse.data.all.find((p) => p.id === selectedProviderId);
+        if (!provider) {
+            await interaction.editReply({
+                content: 'Provider not found',
+                components: [],
+            });
+            return;
+        }
+        const models = Object.entries(provider.models || {})
+            .map(([modelId, model]) => ({
+            id: modelId,
+            name: model.name,
+            releaseDate: model.release_date,
+        }))
+            // Sort by release date descending (most recent first)
+            .sort((a, b) => {
+            const dateA = a.releaseDate ? new Date(a.releaseDate).getTime() : 0;
+            const dateB = b.releaseDate ? new Date(b.releaseDate).getTime() : 0;
+            return dateB - dateA;
+        });
+        if (models.length === 0) {
+            await interaction.editReply({
+                content: `No models available for ${provider.name}`,
+                components: [],
+            });
+            return;
+        }
+        // Take first 25 models (most recent since sorted descending)
+        const recentModels = models.slice(0, 25);
+        // Update context with provider info and reuse the same hash
+        context.providerId = selectedProviderId;
+        context.providerName = provider.name;
+        pendingModelContexts.set(contextHash, context);
+        const options = recentModels.map((model) => {
+            const dateStr = model.releaseDate
+                ? new Date(model.releaseDate).toLocaleDateString()
+                : 'Unknown date';
+            return {
+                label: model.name.slice(0, 100),
+                value: model.id,
+                description: dateStr.slice(0, 100),
+            };
+        });
+        const selectMenu = new StringSelectMenuBuilder()
+            .setCustomId(`model_select:${contextHash}`)
+            .setPlaceholder('Select a model')
+            .addOptions(options);
+        const actionRow = new ActionRowBuilder().addComponents(selectMenu);
+        await interaction.editReply({
+            content: `**Set Model Preference**\nProvider: **${provider.name}**\nSelect a model:`,
+            components: [actionRow],
+        });
+    }
+    catch (error) {
+        modelLogger.error('Error loading models:', error);
+        await interaction.editReply({
+            content: `Failed to load models: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}
+/**
+ * Handle the model select menu interaction.
+ * Stores the model preference in the database.
+ */
+export async function handleModelSelectMenu(interaction) {
+    const customId = interaction.customId;
+    if (!customId.startsWith('model_select:')) {
+        return;
+    }
+    // Defer update immediately
+    await interaction.deferUpdate();
+    const contextHash = customId.replace('model_select:', '');
+    const context = pendingModelContexts.get(contextHash);
+    if (!context || !context.providerId || !context.providerName) {
+        await interaction.editReply({
+            content: 'Selection expired. Please run /model again.',
+            components: [],
+        });
+        return;
+    }
+    const selectedModelId = interaction.values[0];
+    if (!selectedModelId) {
+        await interaction.editReply({
+            content: 'No model selected',
+            components: [],
+        });
+        return;
+    }
+    // Build full model ID: provider_id/model_id
+    const fullModelId = `${context.providerId}/${selectedModelId}`;
+    try {
+        // Store in appropriate table based on context
+        if (context.isThread && context.sessionId) {
+            // Store for session
+            setSessionModel(context.sessionId, fullModelId);
+            modelLogger.log(`Set model ${fullModelId} for session ${context.sessionId}`);
+            // Check if there's a running request and abort+retry with new model
+            let retried = false;
+            if (context.thread) {
+                retried = await abortAndRetrySession({
+                    sessionId: context.sessionId,
+                    thread: context.thread,
+                    projectDirectory: context.dir,
+                });
+            }
+            if (retried) {
+                await interaction.editReply({
+                    content: `Model changed for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\`\n\n_Retrying current request with new model..._`,
+                    components: [],
+                });
+            }
+            else {
+                await interaction.editReply({
+                    content: `Model preference set for this session:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\``,
+                    components: [],
+                });
+            }
+        }
+        else {
+            // Store for channel
+            setChannelModel(context.channelId, fullModelId);
+            modelLogger.log(`Set model ${fullModelId} for channel ${context.channelId}`);
+            await interaction.editReply({
+                content: `Model preference set for this channel:\n**${context.providerName}** / **${selectedModelId}**\n\n\`${fullModelId}\`\n\nAll new sessions in this channel will use this model.`,
+                components: [],
+            });
+        }
+        // Clean up the context from memory
+        pendingModelContexts.delete(contextHash);
+    }
+    catch (error) {
+        modelLogger.error('Error saving model preference:', error);
+        await interaction.editReply({
+            content: `Failed to save model preference: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            components: [],
+        });
+    }
+}

package/dist/commands/permissions.js

@@ -0,0 +1,126 @@
+// Permission commands - /accept, /accept-always, /reject
+import { ChannelType } from 'discord.js';
+import { initializeOpencodeForDirectory } from '../opencode.js';
+import { pendingPermissions } from '../session-handler.js';
+import { SILENT_MESSAGE_FLAGS } from '../discord-utils.js';
+import { createLogger } from '../logger.js';
+const logger = createLogger('PERMISSIONS');
+export async function handleAcceptCommand({ command, }) {
+    const scope = command.commandName === 'accept-always' ? 'always' : 'once';
+    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 pending = pendingPermissions.get(channel.id);
+    if (!pending) {
+        await command.reply({
+            content: 'No pending permission request in this thread',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(pending.directory);
+        await getClient().postSessionIdPermissionsPermissionId({
+            path: {
+                id: pending.permission.sessionID,
+                permissionID: pending.permission.id,
+            },
+            body: {
+                response: scope,
+            },
+        });
+        pendingPermissions.delete(channel.id);
+        const msg = scope === 'always'
+            ? `✅ Permission **accepted** (auto-approve similar requests)`
+            : `✅ Permission **accepted**`;
+        await command.reply({ content: msg, flags: SILENT_MESSAGE_FLAGS });
+        logger.log(`Permission ${pending.permission.id} accepted with scope: ${scope}`);
+    }
+    catch (error) {
+        logger.error('[ACCEPT] Error:', error);
+        await command.reply({
+            content: `Failed to accept permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+}
+export async function handleRejectCommand({ 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 pending = pendingPermissions.get(channel.id);
+    if (!pending) {
+        await command.reply({
+            content: 'No pending permission request in this thread',
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        return;
+    }
+    try {
+        const getClient = await initializeOpencodeForDirectory(pending.directory);
+        await getClient().postSessionIdPermissionsPermissionId({
+            path: {
+                id: pending.permission.sessionID,
+                permissionID: pending.permission.id,
+            },
+            body: {
+                response: 'reject',
+            },
+        });
+        pendingPermissions.delete(channel.id);
+        await command.reply({
+            content: `❌ Permission **rejected**`,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+        logger.log(`Permission ${pending.permission.id} rejected`);
+    }
+    catch (error) {
+        logger.error('[REJECT] Error:', error);
+        await command.reply({
+            content: `Failed to reject permission: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            ephemeral: true,
+            flags: SILENT_MESSAGE_FLAGS,
+        });
+    }
+}