kimaki 0.4.34 → 0.4.36

package/dist/ai-tool-to-genai.js

@@ -150,9 +150,7 @@ export function aiToolToCallableTool(tool, name) {
             const parts = [];
             for (const functionCall of functionCalls) {
                 // Check if this function call matches our tool
-                if (functionCall.name !== toolName &&
-                    name &&
-                    functionCall.name !== name) {
+                if (functionCall.name !== toolName && name && functionCall.name !== name) {
                     continue;
                 }
                 // Execute the tool if it has an execute function

package/dist/channel-management.js

@@ -1,7 +1,7 @@
 // Discord channel and category management.
 // Creates and manages Kimaki project channels (text + voice pairs),
 // extracts channel metadata from topic tags, and ensures category structure.
-import { ChannelType, } from 'discord.js';
+import { ChannelType } from 'discord.js';
 import path from 'node:path';
 import { getDatabase } from './database.js';
 import { extractTagsArrays } from './xml.js';

package/dist/cli.js

@@ -23,11 +23,18 @@ async function killProcessOnPort(port) {
     try {
         if (isWindows) {
             // Windows: find PID using netstat, then kill
-            const result = spawnSync('cmd', ['/c', `for /f "tokens=5" %a in ('netstat -ano ^| findstr :${port} ^| findstr LISTENING') do @echo %a`], {
+            const result = spawnSync('cmd', [
+                '/c',
+                `for /f "tokens=5" %a in ('netstat -ano ^| findstr :${port} ^| findstr LISTENING') do @echo %a`,
+            ], {
                 shell: false,
                 encoding: 'utf-8',
             });
-            const pids = result.stdout?.trim().split('\n').map((p) => p.trim()).filter((p) => /^\d+$/.test(p));
+            const pids = result.stdout
+                ?.trim()
+                .split('\n')
+                .map((p) => p.trim())
+                .filter((p) => /^\d+$/.test(p));
             // Filter out our own PID and take the first (oldest)
             const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid);
             if (targetPid) {
@@ -42,7 +49,11 @@ async function killProcessOnPort(port) {
                 shell: false,
                 encoding: 'utf-8',
             });
-            const pids = result.stdout?.trim().split('\n').map((p) => p.trim()).filter((p) => /^\d+$/.test(p));
+            const pids = result.stdout
+                ?.trim()
+                .split('\n')
+                .map((p) => p.trim())
+                .filter((p) => /^\d+$/.test(p));
             // Filter out our own PID and take the first (oldest)
             const targetPid = pids?.find((p) => parseInt(p, 10) !== myPid);
             if (targetPid) {
@@ -68,7 +79,9 @@ async function checkSingleInstance() {
             cliLogger.log(`Another kimaki instance detected for data dir: ${getDataDir()}`);
             await killProcessOnPort(lockPort);
             // Wait a moment for port to be released
-            await new Promise((resolve) => { setTimeout(resolve, 500); });
+            await new Promise((resolve) => {
+                setTimeout(resolve, 500);
+            });
         }
     }
     catch {
@@ -91,7 +104,9 @@ async function startLockServer() {
             if (err.code === 'EADDRINUSE') {
                 cliLogger.log('Port still in use, retrying...');
                 await killProcessOnPort(lockPort);
-                await new Promise((r) => { setTimeout(r, 500); });
+                await new Promise((r) => {
+                    setTimeout(r, 500);
+                });
                 // Retry once
                 server.listen(lockPort, '127.0.0.1');
             }
@@ -122,10 +137,7 @@ async function registerCommands(token, appId, userCommands = []) {
             .setName('session')
             .setDescription('Start a new OpenCode session')
             .addStringOption((option) => {
-            option
-                .setName('prompt')
-                .setDescription('Prompt content for the session')
-                .setRequired(true);
+            option.setName('prompt').setDescription('Prompt content for the session').setRequired(true);
             return option;
         })
             .addStringOption((option) => {
@@ -135,6 +147,13 @@ async function registerCommands(token, appId, userCommands = []) {
                 .setAutocomplete(true)
                 .setMaxLength(6000);
             return option;
+        })
+            .addStringOption((option) => {
+            option
+                .setName('agent')
+                .setDescription('Agent to use for this session')
+                .setAutocomplete(true);
+            return option;
         })
             .toJSON(),
         new SlashCommandBuilder()
@@ -149,14 +168,23 @@ async function registerCommands(token, appId, userCommands = []) {
             return option;
         })
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('remove-project')
+            .setDescription('Remove Discord channels for a project')
+            .addStringOption((option) => {
+            option
+                .setName('project')
+                .setDescription('Select a project to remove')
+                .setRequired(true)
+                .setAutocomplete(true);
+            return option;
+        })
+            .toJSON(),
         new SlashCommandBuilder()
             .setName('create-new-project')
             .setDescription('Create a new project folder, initialize git, and start a session')
             .addStringOption((option) => {
-            option
-                .setName('name')
-                .setDescription('Name for the new project folder')
-                .setRequired(true);
+            option.setName('name').setDescription('Name for the new project folder').setRequired(true);
             return option;
         })
             .toJSON(),
@@ -188,10 +216,7 @@ async function registerCommands(token, appId, userCommands = []) {
             .setName('queue')
             .setDescription('Queue a message to be sent after the current response finishes')
             .addStringOption((option) => {
-            option
-                .setName('message')
-                .setDescription('The message to queue')
-                .setRequired(true);
+            option.setName('message').setDescription('The message to queue').setRequired(true);
             return option;
         })
             .toJSON(),
@@ -218,7 +243,7 @@ async function registerCommands(token, appId, userCommands = []) {
         const commandName = `${sanitizedName}-cmd`;
         const description = cmd.description || `Run /${cmd.name} command`;
         commands.push(new SlashCommandBuilder()
-            .setName(commandName)
+            .setName(commandName.slice(0, 32)) // Discord limits to 32 chars
             .setDescription(description.slice(0, 100)) // Discord limits to 100 chars
             .addStringOption((option) => {
             option
@@ -470,11 +495,7 @@ async function run({ restart, addChannels }) {
     if (kimakiChannels.length > 0) {
         const channelList = kimakiChannels
             .flatMap(({ guild, channels }) => channels.map((ch) => {
-            const appInfo = ch.kimakiApp === appId
-                ? ' (this bot)'
-                : ch.kimakiApp
-                    ? ` (app: ${ch.kimakiApp})`
-                    : '';
+            const appInfo = ch.kimakiApp === appId ? ' (this bot)' : ch.kimakiApp ? ` (app: ${ch.kimakiApp})` : '';
             return `#${ch.name} in ${guild.name}: ${ch.kimakiDirectory}${appInfo}`;
         }))
             .join('\n');
@@ -487,13 +508,19 @@ async function run({ restart, addChannels }) {
     s.start('Fetching OpenCode data...');
     // Fetch projects and commands in parallel
     const [projects, allUserCommands] = await Promise.all([
-        getClient().project.list({}).then((r) => r.data || []).catch((error) => {
+        getClient()
+            .project.list({})
+            .then((r) => r.data || [])
+            .catch((error) => {
             s.stop('Failed to fetch projects');
             cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
             discordClient.destroy();
             process.exit(EXIT_NO_RESTART);
         }),
-        getClient().command.list({ query: { directory: currentDir } }).then((r) => r.data || []).catch(() => []),
+        getClient()
+            .command.list({ query: { directory: currentDir } })
+            .then((r) => r.data || [])
+            .catch(() => []),
     ]);
     s.stop(`Found ${projects.length} OpenCode project(s)`);
     const existingDirs = kimakiChannels.flatMap(({ channels }) => channels
@@ -512,8 +539,7 @@ async function run({ restart, addChannels }) {
     if (availableProjects.length === 0) {
         note('All OpenCode projects already have Discord channels', 'No New Projects');
     }
-    if ((!existingDirs?.length && availableProjects.length > 0) ||
-        shouldAddChannels) {
+    if ((!existingDirs?.length && availableProjects.length > 0) || shouldAddChannels) {
         const selectedProjects = await multiselect({
             message: 'Select projects to create Discord channels for:',
             options: availableProjects.map((project) => ({
@@ -613,7 +639,8 @@ async function run({ restart, addChannels }) {
             .join('\n');
         note(`Your kimaki channels are ready! Click any link below to open in Discord:\n\n${channelLinks}\n\nSend a message in any channel to start using OpenCode!`, '🚀 Ready to Use');
     }
-    outro('✨ Setup complete!');
+    note('Leave this process running to keep the bot active.\n\nIf you close this process or restart your machine, run `npx kimaki` again to start the bot.', '⚠️  Keep Running');
+    outro('✨ Setup complete! Listening for new messages... do not close this process.');
 }
 cli
     .command('', 'Set up and run the Kimaki Discord bot')
@@ -695,13 +722,13 @@ cli
             const buffer = fs.readFileSync(file);
             const formData = new FormData();
             formData.append('payload_json', JSON.stringify({
-                attachments: [{ id: 0, filename: path.basename(file) }]
+                attachments: [{ id: 0, filename: path.basename(file) }],
             }));
             formData.append('files[0]', new Blob([buffer]), path.basename(file));
             const response = await fetch(`https://discord.com/api/v10/channels/${threadRow.thread_id}/messages`, {
                 method: 'POST',
                 headers: {
-                    'Authorization': `Bot ${botRow.token}`,
+                    Authorization: `Bot ${botRow.token}`,
                 },
                 body: formData,
             });
@@ -725,14 +752,16 @@ const BOT_SESSION_PREFIX = '🤖 **Bot-initiated session**';
 cli
     .command('start-session', 'Start a new session in a Discord channel (creates thread, bot handles the rest)')
     .option('-c, --channel <channelId>', 'Discord channel ID')
+    .option('-d, --project <path>', 'Project directory (alternative to --channel)')
     .option('-p, --prompt <prompt>', 'Initial prompt for the session')
     .option('-n, --name [name]', 'Thread name (optional, defaults to prompt preview)')
     .option('-a, --app-id [appId]', 'Bot application ID (required if no local database)')
     .action(async (options) => {
     try {
-        const { channel: channelId, prompt, name, appId: optionAppId } = options;
-        if (!channelId) {
-            cliLogger.error('Channel ID is required. Use --channel <channelId>');
+        let { channel: channelId, prompt, name, appId: optionAppId } = options;
+        const { project: projectPath } = options;
+        if (!channelId && !projectPath) {
+            cliLogger.error('Either --channel or --project is required');
             process.exit(EXIT_NO_RESTART);
         }
         if (!prompt) {
@@ -781,11 +810,85 @@ cli
             process.exit(EXIT_NO_RESTART);
         }
         const s = spinner();
+        // If --project provided, resolve to channel ID
+        if (projectPath) {
+            const absolutePath = path.resolve(projectPath);
+            if (!fs.existsSync(absolutePath)) {
+                cliLogger.error(`Directory does not exist: ${absolutePath}`);
+                process.exit(EXIT_NO_RESTART);
+            }
+            s.start('Looking up channel for project...');
+            // Check if channel already exists for this directory
+            try {
+                const db = getDatabase();
+                const existingChannel = db
+                    .prepare('SELECT channel_id FROM channel_directories WHERE directory = ? AND channel_type = ?')
+                    .get(absolutePath, 'text');
+                if (existingChannel) {
+                    channelId = existingChannel.channel_id;
+                    s.message(`Found existing channel: ${channelId}`);
+                }
+                else {
+                    // Need to create a new channel
+                    s.message('Creating new channel...');
+                    if (!appId) {
+                        s.stop('Missing app ID');
+                        cliLogger.error('App ID is required to create channels. Use --app-id or run `kimaki` first.');
+                        process.exit(EXIT_NO_RESTART);
+                    }
+                    const client = await createDiscordClient();
+                    await new Promise((resolve, reject) => {
+                        client.once(Events.ClientReady, () => {
+                            resolve();
+                        });
+                        client.once(Events.Error, reject);
+                        client.login(botToken);
+                    });
+                    // Get guild from existing channels or first available
+                    const guild = await (async () => {
+                        // Try to find a guild from existing channels
+                        const existingChannelRow = db
+                            .prepare('SELECT channel_id FROM channel_directories ORDER BY created_at DESC LIMIT 1')
+                            .get();
+                        if (existingChannelRow) {
+                            try {
+                                const ch = await client.channels.fetch(existingChannelRow.channel_id);
+                                if (ch && 'guild' in ch && ch.guild) {
+                                    return ch.guild;
+                                }
+                            }
+                            catch {
+                                // Channel might be deleted, continue
+                            }
+                        }
+                        // Fall back to first guild
+                        const firstGuild = client.guilds.cache.first();
+                        if (!firstGuild) {
+                            throw new Error('No guild found. Add the bot to a server first.');
+                        }
+                        return firstGuild;
+                    })();
+                    const { textChannelId } = await createProjectChannels({
+                        guild,
+                        projectDirectory: absolutePath,
+                        appId,
+                        botName: client.user?.username,
+                    });
+                    channelId = textChannelId;
+                    s.message(`Created channel: ${channelId}`);
+                    client.destroy();
+                }
+            }
+            catch (e) {
+                s.stop('Failed to resolve project');
+                throw e;
+            }
+        }
         s.start('Fetching channel info...');
         // Get channel info to extract directory from topic
         const channelResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}`, {
             headers: {
-                'Authorization': `Bot ${botToken}`,
+                Authorization: `Bot ${botToken}`,
             },
         });
         if (!channelResponse.ok) {
@@ -793,7 +896,7 @@ cli
             s.stop('Failed to fetch channel');
             throw new Error(`Discord API error: ${channelResponse.status} - ${error}`);
         }
-        const channelData = await channelResponse.json();
+        const channelData = (await channelResponse.json());
         if (!channelData.topic) {
             s.stop('Channel has no topic');
             throw new Error(`Channel #${channelData.name} has no topic. It must have a <kimaki.directory> tag.`);
@@ -819,7 +922,7 @@ cli
         const starterMessageResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {
             method: 'POST',
             headers: {
-                'Authorization': `Bot ${botToken}`,
+                Authorization: `Bot ${botToken}`,
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
@@ -831,14 +934,14 @@ cli
             s.stop('Failed to create message');
             throw new Error(`Discord API error: ${starterMessageResponse.status} - ${error}`);
         }
-        const starterMessage = await starterMessageResponse.json();
+        const starterMessage = (await starterMessageResponse.json());
         s.message('Creating thread...');
         // Create thread from the message
         const threadName = name || (prompt.length > 80 ? prompt.slice(0, 77) + '...' : prompt);
         const threadResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages/${starterMessage.id}/threads`, {
             method: 'POST',
             headers: {
-                'Authorization': `Bot ${botToken}`,
+                Authorization: `Bot ${botToken}`,
                 'Content-Type': 'application/json',
             },
             body: JSON.stringify({
@@ -851,7 +954,7 @@ cli
             s.stop('Failed to create thread');
             throw new Error(`Discord API error: ${threadResponse.status} - ${error}`);
         }
-        const threadData = await threadResponse.json();
+        const threadData = (await threadResponse.json());
         s.stop('Thread created!');
         const threadUrl = `https://discord.com/channels/${channelData.guild_id}/${threadData.id}`;
         note(`Thread: ${threadData.name}\nDirectory: ${projectDirectory}\n\nThe running bot will pick this up and start the session.\n\nURL: ${threadUrl}`, '✅ Thread Created');

package/dist/commands/abort.js

@@ -6,7 +6,7 @@ import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../
 import { abortControllers } from '../session-handler.js';
 import { createLogger } from '../logger.js';
 const logger = createLogger('ABORT');
-export async function handleAbortCommand({ command, }) {
+export async function handleAbortCommand({ command }) {
     const channel = command.channel;
     if (!channel) {
         await command.reply({

package/dist/commands/add-project.js

@@ -7,7 +7,7 @@ import { createProjectChannels } from '../channel-management.js';
 import { createLogger } from '../logger.js';
 import { abbreviatePath } from '../utils.js';
 const logger = createLogger('ADD-PROJECT');
-export async function handleAddProjectCommand({ command, appId, }) {
+export async function handleAddProjectCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
     const projectId = command.options.getString('project', true);
     const guild = command.guild;

package/dist/commands/agent.js

@@ -44,7 +44,9 @@ export async function handleAgentCommand({ interaction, appId, }) {
         targetChannelId = channel.id;
     }
     else {
-        await interaction.editReply({ content: 'This command can only be used in text channels or threads' });
+        await interaction.editReply({
+            content: 'This command can only be used in text channels or threads',
+        });
         return;
     }
     if (channelAppId && channelAppId !== appId) {
@@ -52,7 +54,9 @@ export async function handleAgentCommand({ interaction, appId, }) {
         return;
     }
     if (!projectDirectory) {
-        await interaction.editReply({ content: 'This channel is not configured with a project directory' });
+        await interaction.editReply({
+            content: 'This channel is not configured with a project directory',
+        });
         return;
     }
     try {

package/dist/commands/ask-question.js

@@ -44,9 +44,10 @@ export async function showAskUserQuestionDropdowns({ thread, sessionId, director
                 description: 'Provide a custom answer in chat',
             },
         ];
+        const placeholder = options.find((x) => x.label)?.label || 'Select an option';
         const selectMenu = new StringSelectMenuBuilder()
             .setCustomId(`ask_question:${contextHash}:${i}`)
-            .setPlaceholder(`Select an option`)
+            .setPlaceholder(placeholder)
             .addOptions(options);
         // Enable multi-select if the question supports it
         if (q.multiple) {

package/dist/commands/fork.js

@@ -84,8 +84,7 @@ export async function handleForkCommand(interaction) {
             .setCustomId(`fork_select:${sessionId}:${encodedDir}`)
             .setPlaceholder('Select a message to fork from')
             .addOptions(options);
-        const actionRow = new ActionRowBuilder()
-            .addComponents(selectMenu);
+        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],
@@ -133,11 +132,12 @@ export async function handleForkSelectMenu(interaction) {
         }
         const forkedSession = forkResponse.data;
         const parentChannel = interaction.channel;
-        if (!parentChannel || ![
-            ChannelType.PublicThread,
-            ChannelType.PrivateThread,
-            ChannelType.AnnouncementThread,
-        ].includes(parentChannel.type)) {
+        if (!parentChannel ||
+            ![
+                ChannelType.PublicThread,
+                ChannelType.PrivateThread,
+                ChannelType.AnnouncementThread,
+            ].includes(parentChannel.type)) {
             await interaction.editReply('Could not access parent channel');
             return;
         }

package/dist/commands/queue.js

@@ -5,7 +5,7 @@ import { resolveTextChannel, getKimakiMetadata, sendThreadMessage, SILENT_MESSAG
 import { handleOpencodeSession, abortControllers, addToQueue, getQueueLength, clearQueue, } from '../session-handler.js';
 import { createLogger } from '../logger.js';
 const logger = createLogger('QUEUE');
-export async function handleQueueCommand({ command, }) {
+export async function handleQueueCommand({ command }) {
     const message = command.options.getString('message', true);
     const channel = command.channel;
     if (!channel) {
@@ -88,7 +88,7 @@ export async function handleQueueCommand({ command, }) {
     });
     logger.log(`[QUEUE] User ${command.user.displayName} queued message in thread ${channel.id}`);
 }
-export async function handleClearQueueCommand({ command, }) {
+export async function handleClearQueueCommand({ command }) {
     const channel = command.channel;
     if (!channel) {
         await command.reply({

package/dist/commands/remove-project.js

@@ -0,0 +1,109 @@
+// /remove-project command - Remove Discord channels for a project.
+import path from 'node:path';
+import { getDatabase } from '../database.js';
+import { createLogger } from '../logger.js';
+import { abbreviatePath } from '../utils.js';
+const logger = createLogger('REMOVE-PROJECT');
+export async function handleRemoveProjectCommand({ command, appId }) {
+    await command.deferReply({ ephemeral: false });
+    const directory = command.options.getString('project', true);
+    const guild = command.guild;
+    if (!guild) {
+        await command.editReply('This command can only be used in a guild');
+        return;
+    }
+    try {
+        const db = getDatabase();
+        // Get channel IDs for this directory
+        const channels = db
+            .prepare('SELECT channel_id, channel_type FROM channel_directories WHERE directory = ?')
+            .all(directory);
+        if (channels.length === 0) {
+            await command.editReply(`No channels found for directory: \`${directory}\``);
+            return;
+        }
+        const deletedChannels = [];
+        const failedChannels = [];
+        for (const { channel_id, channel_type } of channels) {
+            try {
+                const channel = await guild.channels.fetch(channel_id).catch(() => null);
+                if (channel) {
+                    await channel.delete(`Removed by /remove-project command`);
+                    deletedChannels.push(`${channel_type}: ${channel_id}`);
+                }
+                else {
+                    // Channel doesn't exist in this guild or was already deleted
+                    deletedChannels.push(`${channel_type}: ${channel_id} (already deleted)`);
+                }
+            }
+            catch (error) {
+                logger.error(`Failed to delete channel ${channel_id}:`, error);
+                failedChannels.push(`${channel_type}: ${channel_id}`);
+            }
+        }
+        // Remove from database
+        db.prepare('DELETE FROM channel_directories WHERE directory = ?').run(directory);
+        const projectName = path.basename(directory);
+        let message = `Removed project **${projectName}**\n`;
+        message += `Directory: \`${directory}\`\n\n`;
+        if (deletedChannels.length > 0) {
+            message += `Deleted channels:\n${deletedChannels.map((c) => `- ${c}`).join('\n')}`;
+        }
+        if (failedChannels.length > 0) {
+            message += `\n\nFailed to delete (may be in another server):\n${failedChannels.map((c) => `- ${c}`).join('\n')}`;
+        }
+        await command.editReply(message);
+        logger.log(`Removed project ${projectName} at ${directory}`);
+    }
+    catch (error) {
+        logger.error('[REMOVE-PROJECT] Error:', error);
+        await command.editReply(`Failed to remove project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+export async function handleRemoveProjectAutocomplete({ interaction, appId, }) {
+    const focusedValue = interaction.options.getFocused();
+    const guild = interaction.guild;
+    if (!guild) {
+        await interaction.respond([]);
+        return;
+    }
+    try {
+        const db = getDatabase();
+        // Get all directories with channels
+        const allChannels = db
+            .prepare('SELECT DISTINCT directory, channel_id FROM channel_directories WHERE channel_type = ?')
+            .all('text');
+        // Filter to only channels that exist in this guild
+        const projectsInGuild = [];
+        for (const { directory, channel_id } of allChannels) {
+            try {
+                const channel = await guild.channels.fetch(channel_id).catch(() => null);
+                if (channel) {
+                    projectsInGuild.push({ directory, channelId: channel_id });
+                }
+            }
+            catch {
+                // Channel not in this guild, skip
+            }
+        }
+        const projects = projectsInGuild
+            .filter(({ directory }) => {
+            const baseName = path.basename(directory);
+            const searchText = `${baseName} ${directory}`.toLowerCase();
+            return searchText.includes(focusedValue.toLowerCase());
+        })
+            .slice(0, 25)
+            .map(({ directory }) => {
+            const name = `${path.basename(directory)} (${abbreviatePath(directory)})`;
+            return {
+                name: name.length > 100 ? name.slice(0, 99) + '...' : name,
+                value: directory,
+            };
+        });
+        await interaction.respond(projects);
+    }
+    catch (error) {
+        logger.error('[AUTOCOMPLETE] Error fetching projects:', error);
+        await interaction.respond([]);
+    }
+}

package/dist/commands/resume.js

@@ -3,12 +3,12 @@ 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 { 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, }) {
+export async function handleResumeCommand({ command, appId }) {
     await command.deferReply({ ephemeral: false });
     const sessionId = command.options.getString('session', true);
     const channel = command.channel;
@@ -116,9 +116,7 @@ export async function handleResumeAutocomplete({ interaction, appId, }) {
             await interaction.respond([]);
             return;
         }
-        const existingSessionIds = new Set(getDatabase()
-            .prepare('SELECT session_id FROM thread_sessions')
-            .all().map((row) => row.session_id));
+        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()))