kimaki 0.4.13 → 0.4.14

package/dist/cli.js

@@ -3,7 +3,7 @@ import { cac } from 'cac';
 import { intro, outro, text, password, note, cancel, isCancel, confirm, log, multiselect, spinner, } from '@clack/prompts';
 import { deduplicateByKey, generateBotInstallUrl } from './utils.js';
 import { getChannelsWithDescriptions, createDiscordClient, getDatabase, startDiscordBot, initializeOpencodeForDirectory, ensureKimakiCategory, createProjectChannels, } from './discordBot.js';
-import { Events, ChannelType, REST, Routes, SlashCommandBuilder, } from 'discord.js';
+import { Events, ChannelType, REST, Routes, SlashCommandBuilder, AttachmentBuilder, } from 'discord.js';
 import path from 'node:path';
 import fs from 'node:fs';
 import { createRequire } from 'node:module';
@@ -78,12 +78,16 @@ async function registerCommands(token, appId) {
             .toJSON(),
         new SlashCommandBuilder()
             .setName('accept-always')
-            .setDescription('Accept and auto-approve future requests matching this pattern (e.g. "git *" approves all git commands)')
+            .setDescription('Accept and auto-approve future requests matching this pattern')
             .toJSON(),
         new SlashCommandBuilder()
             .setName('reject')
             .setDescription('Reject a pending permission request')
             .toJSON(),
+        new SlashCommandBuilder()
+            .setName('abort')
+            .setDescription('Abort the current OpenCode request in this thread')
+            .toJSON(),
     ];
     const rest = new REST().setToken(token);
     try {
@@ -558,22 +562,87 @@ cli
     }
 });
 cli
-    .command('install-plugin', 'Install the OpenCode plugin for /send-to-kimaki-discord command')
+    .command('upload-to-discord [...files]', 'Upload files to a Discord thread for a session')
+    .option('-s, --session <sessionId>', 'OpenCode session ID')
+    .action(async (files, options) => {
+    try {
+        const { session: sessionId } = options;
+        if (!sessionId) {
+            cliLogger.error('Session ID is required. Use --session <sessionId>');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (!files || files.length === 0) {
+            cliLogger.error('At least one file path is required');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const resolvedFiles = files.map((f) => path.resolve(f));
+        for (const file of resolvedFiles) {
+            if (!fs.existsSync(file)) {
+                cliLogger.error(`File not found: ${file}`);
+                process.exit(EXIT_NO_RESTART);
+            }
+        }
+        const db = getDatabase();
+        const threadRow = db
+            .prepare('SELECT thread_id FROM thread_sessions WHERE session_id = ?')
+            .get(sessionId);
+        if (!threadRow) {
+            cliLogger.error(`No Discord thread found for session: ${sessionId}`);
+            cliLogger.error('Make sure the session has been sent to Discord first using /send-to-kimaki-discord');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const botRow = db
+            .prepare('SELECT app_id, token FROM bot_tokens ORDER BY created_at DESC LIMIT 1')
+            .get();
+        if (!botRow) {
+            cliLogger.error('No bot credentials found. Run `kimaki` first to set up the bot.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        const s = spinner();
+        s.start(`Uploading ${resolvedFiles.length} file(s)...`);
+        for (const file of resolvedFiles) {
+            const buffer = fs.readFileSync(file);
+            const formData = new FormData();
+            formData.append('payload_json', JSON.stringify({
+                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}`,
+                },
+                body: formData,
+            });
+            if (!response.ok) {
+                const error = await response.text();
+                throw new Error(`Discord API error: ${response.status} - ${error}`);
+            }
+        }
+        s.stop(`Uploaded ${resolvedFiles.length} file(s)!`);
+        note(`Files uploaded to Discord thread!\n\nFiles: ${resolvedFiles.map((f) => path.basename(f)).join(', ')}`, '✅ Success');
+        process.exit(0);
+    }
+    catch (error) {
+        cliLogger.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(EXIT_NO_RESTART);
+    }
+});
+cli
+    .command('install-plugin', 'Install the OpenCode commands for kimaki Discord integration')
     .action(async () => {
     try {
         const require = createRequire(import.meta.url);
-        const pluginSrc = require.resolve('./opencode-plugin.ts');
-        const commandSrc = require.resolve('./opencode-command.md');
+        const sendCommandSrc = require.resolve('./opencode-command-send-to-discord.md');
+        const uploadCommandSrc = require.resolve('./opencode-command-upload-to-discord.md');
         const opencodeConfig = path.join(os.homedir(), '.config', 'opencode');
-        const pluginDir = path.join(opencodeConfig, 'plugin');
         const commandDir = path.join(opencodeConfig, 'command');
-        fs.mkdirSync(pluginDir, { recursive: true });
         fs.mkdirSync(commandDir, { recursive: true });
-        const pluginDest = path.join(pluginDir, 'send-to-kimaki-discord.ts');
-        const commandDest = path.join(commandDir, 'send-to-kimaki-discord.md');
-        fs.copyFileSync(pluginSrc, pluginDest);
-        fs.copyFileSync(commandSrc, commandDest);
-        note(`Plugin: ${pluginDest}\nCommand: ${commandDest}\n\nUse /send-to-kimaki-discord in OpenCode to send the current session to Discord.`, '✅ Installed');
+        const sendCommandDest = path.join(commandDir, 'send-to-kimaki-discord.md');
+        const uploadCommandDest = path.join(commandDir, 'upload-to-discord.md');
+        fs.copyFileSync(sendCommandSrc, sendCommandDest);
+        fs.copyFileSync(uploadCommandSrc, uploadCommandDest);
+        note(`Commands installed:\n- ${sendCommandDest}\n- ${uploadCommandDest}\n\nUse /send-to-kimaki-discord to send session to Discord.\nUse /upload-to-discord to upload files to the thread.`, '✅ Installed');
         process.exit(0);
     }
     catch (error) {

package/dist/discordBot.js

@@ -22,9 +22,25 @@ import { isAbortError } from './utils.js';
 import { setGlobalDispatcher, Agent } from 'undici';
 // disables the automatic 5 minutes abort after no body
 setGlobalDispatcher(new Agent({ headersTimeout: 0, bodyTimeout: 0 }));
-export const OPENCODE_SYSTEM_MESSAGE = `
+function parseSlashCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('/')) {
+        return { isCommand: false };
+    }
+    const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/);
+    if (!match) {
+        return { isCommand: false };
+    }
+    const command = match[1];
+    const args = match[2]?.trim() || '';
+    return { isCommand: true, command, arguments: args };
+}
+export function getOpencodeSystemMessage({ sessionId }) {
+    return `
 The user is reading your messages from inside Discord, via kimaki.xyz
 
+Your current OpenCode session ID is: ${sessionId}
+
 After each message, if you implemented changes, you can show the user a diff via an url running the command, to show the changes in working directory:
 
 bunx critique web
@@ -66,6 +82,7 @@ code blocks for tables and diagrams MUST have Max length of 85 characters. other
 
 you can create diagrams wrapping them in code blocks too.
 `;
+}
 const discordLogger = createLogger('DISCORD');
 const voiceLogger = createLogger('VOICE');
 const opencodeLogger = createLogger('OPENCODE');
@@ -1023,7 +1040,7 @@ export async function createDiscordClient() {
         ],
     });
 }
-async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], }) {
+async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], parsedCommand, }) {
     voiceLogger.log(`[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`);
     // Track session start time
     const sessionStartTime = Date.now();
@@ -1117,6 +1134,8 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
     let currentParts = [];
     let stopTyping = null;
     let usedModel;
+    let usedProviderID;
+    let inputTokens = 0;
     const sendPartMessage = async (part) => {
         const content = formatPart(part) + '\n\n';
         if (!content.trim() || content.length === 0) {
@@ -1125,14 +1144,11 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
         // Skip if already sent
         if (partIdToMessage.has(part.id)) {
-            voiceLogger.log(`[SEND SKIP] Part ${part.id} already sent as message ${partIdToMessage.get(part.id)?.id}`);
             return;
         }
         try {
-            voiceLogger.log(`[SEND] Sending part ${part.id} (type: ${part.type}) to Discord, content length: ${content.length}`);
             const firstMessage = await sendThreadMessage(thread, content);
             partIdToMessage.set(part.id, firstMessage);
-            voiceLogger.log(`[SEND SUCCESS] Part ${part.id} sent as message ${firstMessage.id}`);
             // Store part-message mapping in database
             getDatabase()
                 .prepare('INSERT OR REPLACE INTO part_messages (part_id, message_id, thread_id) VALUES (?, ?, ?)')
@@ -1151,12 +1167,10 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                 discordLogger.log(`Not starting typing, already aborted`);
                 return () => { };
             }
-            discordLogger.log(`Starting typing for thread ${thread.id}`);
             // Clear any previous typing interval
             if (typingInterval) {
                 clearInterval(typingInterval);
                 typingInterval = null;
-                discordLogger.log(`Cleared previous typing interval`);
             }
             // Send initial typing
             thread.sendTyping().catch((e) => {
@@ -1184,39 +1198,34 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                 if (typingInterval) {
                     clearInterval(typingInterval);
                     typingInterval = null;
-                    discordLogger.log(`Stopped typing for thread ${thread.id}`);
                 }
             };
         }
         try {
             let assistantMessageId;
             for await (const event of events) {
-                sessionLogger.log(`Received: ${event.type}`);
                 if (event.type === 'message.updated') {
                     const msg = event.properties.info;
                     if (msg.sessionID !== session.id) {
-                        voiceLogger.log(`[EVENT IGNORED] Message from different session (expected: ${session.id}, got: ${msg.sessionID})`);
                         continue;
                     }
                     // Track assistant message ID
                     if (msg.role === 'assistant') {
                         assistantMessageId = msg.id;
                         usedModel = msg.modelID;
-                        voiceLogger.log(`[EVENT] Tracking assistant message ${assistantMessageId}`);
-                    }
-                    else {
-                        sessionLogger.log(`Message role: ${msg.role}`);
+                        usedProviderID = msg.providerID;
+                        if (msg.tokens.input > 0) {
+                            inputTokens = msg.tokens.input;
+                        }
                     }
                 }
                 else if (event.type === 'message.part.updated') {
                     const part = event.properties.part;
                     if (part.sessionID !== session.id) {
-                        voiceLogger.log(`[EVENT IGNORED] Part from different session (expected: ${session.id}, got: ${part.sessionID})`);
                         continue;
                     }
                     // Only process parts from assistant messages
                     if (part.messageID !== assistantMessageId) {
-                        voiceLogger.log(`[EVENT IGNORED] Part from non-assistant message (expected: ${assistantMessageId}, got: ${part.messageID})`);
                         continue;
                     }
                     const existingIndex = currentParts.findIndex((p) => p.id === part.id);
@@ -1226,15 +1235,18 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                     else {
                         currentParts.push(part);
                     }
-                    voiceLogger.log(`[PART] Update: id=${part.id}, type=${part.type}, text=${'text' in part && typeof part.text === 'string' ? part.text.slice(0, 50) : ''}`);
                     // Start typing on step-start
                     if (part.type === 'step-start') {
                         stopTyping = startTyping(thread);
                     }
                     // Check if this is a step-finish part
                     if (part.type === 'step-finish') {
+                        // Track tokens from step-finish part
+                        if (part.tokens?.input && part.tokens.input > 0) {
+                            inputTokens = part.tokens.input;
+                            voiceLogger.log(`[STEP-FINISH] Captured tokens: ${inputTokens}`);
+                        }
                         // Send all parts accumulated so far to Discord
-                        voiceLogger.log(`[STEP-FINISH] Sending ${currentParts.length} parts to Discord`);
                         for (const p of currentParts) {
                             // Skip step-start and step-finish parts as they have no visual content
                             if (p.type !== 'step-start' && p.type !== 'step-finish') {
@@ -1305,12 +1317,6 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                         pendingPermissions.delete(thread.id);
                     }
                 }
-                else if (event.type === 'file.edited') {
-                    sessionLogger.log(`File edited event received`);
-                }
-                else {
-                    sessionLogger.log(`Unhandled event type: ${event.type}`);
-                }
             }
         }
         catch (e) {
@@ -1323,31 +1329,20 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
         finally {
             // Send any remaining parts that weren't sent
-            voiceLogger.log(`[CLEANUP] Checking ${currentParts.length} parts for unsent messages`);
-            let unsentCount = 0;
             for (const part of currentParts) {
                 if (!partIdToMessage.has(part.id)) {
-                    unsentCount++;
-                    voiceLogger.log(`[CLEANUP] Sending unsent part: id=${part.id}, type=${part.type}`);
                     try {
                         await sendPartMessage(part);
                     }
                     catch (error) {
-                        sessionLogger.log(`Failed to send part ${part.id} during cleanup:`, error);
+                        sessionLogger.error(`Failed to send part ${part.id}:`, error);
                     }
                 }
             }
-            if (unsentCount === 0) {
-                sessionLogger.log(`All parts were already sent`);
-            }
-            else {
-                sessionLogger.log(`Sent ${unsentCount} previously unsent parts`);
-            }
             // Stop typing when session ends
             if (stopTyping) {
                 stopTyping();
                 stopTyping = null;
-                sessionLogger.log(`Stopped typing for session`);
             }
             // Only send duration message if request was not aborted or was aborted with 'finished' reason
             if (!abortController.signal.aborted ||
@@ -1355,8 +1350,23 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
                 const sessionDuration = prettyMilliseconds(Date.now() - sessionStartTime);
                 const attachCommand = port ? ` ⋅ ${session.id}` : '';
                 const modelInfo = usedModel ? ` ⋅ ${usedModel}` : '';
-                await sendThreadMessage(thread, `_Completed in ${sessionDuration}_${attachCommand}${modelInfo}`);
-                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}`);
+                let contextInfo = '';
+                if (inputTokens > 0 && usedProviderID && usedModel) {
+                    try {
+                        const providersResponse = await getClient().provider.list({ query: { directory } });
+                        const provider = providersResponse.data?.all?.find((p) => p.id === usedProviderID);
+                        const model = provider?.models?.[usedModel];
+                        if (model?.limit?.context) {
+                            const percentage = Math.round((inputTokens / model.limit.context) * 100);
+                            contextInfo = ` ⋅ ${percentage}%`;
+                        }
+                    }
+                    catch (e) {
+                        sessionLogger.error('Failed to fetch provider info for context percentage:', e);
+                    }
+                }
+                await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`);
+                sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${inputTokens}`);
             }
             else {
                 sessionLogger.log(`Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`);
@@ -1364,22 +1374,36 @@ async function handleOpencodeSession({ prompt, thread, projectDirectory, origina
         }
     };
     try {
-        voiceLogger.log(`[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
-        if (images.length > 0) {
-            sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })));
-        }
         // Start the event handler
         const eventHandlerPromise = eventHandler();
-        const parts = [{ type: 'text', text: prompt }, ...images];
-        sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
-        const response = await getClient().session.prompt({
-            path: { id: session.id },
-            body: {
-                parts,
-                system: OPENCODE_SYSTEM_MESSAGE,
-            },
-            signal: abortController.signal,
-        });
+        let response;
+        if (parsedCommand?.isCommand) {
+            sessionLogger.log(`[COMMAND] Sending command /${parsedCommand.command} to session ${session.id} with args: "${parsedCommand.arguments.slice(0, 100)}${parsedCommand.arguments.length > 100 ? '...' : ''}"`);
+            response = await getClient().session.command({
+                path: { id: session.id },
+                body: {
+                    command: parsedCommand.command,
+                    arguments: parsedCommand.arguments,
+                },
+                signal: abortController.signal,
+            });
+        }
+        else {
+            voiceLogger.log(`[PROMPT] Sending prompt to session ${session.id}: "${prompt.slice(0, 100)}${prompt.length > 100 ? '...' : ''}"`);
+            if (images.length > 0) {
+                sessionLogger.log(`[PROMPT] Sending ${images.length} image(s):`, images.map((img) => ({ mime: img.mime, filename: img.filename, url: img.url.slice(0, 100) })));
+            }
+            const parts = [{ type: 'text', text: prompt }, ...images];
+            sessionLogger.log(`[PROMPT] Parts to send:`, parts.length);
+            response = await getClient().session.prompt({
+                path: { id: session.id },
+                body: {
+                    parts,
+                    system: getOpencodeSystemMessage({ sessionId: session.id }),
+                },
+                signal: abortController.signal,
+            });
+        }
         abortController.abort('finished');
         sessionLogger.log(`Successfully sent prompt, got response`);
         // Update reaction to success
@@ -1493,7 +1517,6 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
     discordClient.on(Events.MessageCreate, async (message) => {
         try {
             if (message.author?.bot) {
-                voiceLogger.log(`[IGNORED] Bot message from ${message.author.tag} in channel ${message.channelId}`);
                 return;
             }
             if (message.partial) {
@@ -1511,10 +1534,8 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                 const isOwner = message.member.id === message.guild.ownerId;
                 const isAdmin = message.member.permissions.has(PermissionsBitField.Flags.Administrator);
                 if (!isOwner && !isAdmin) {
-                    voiceLogger.log(`[IGNORED] Non-authoritative user ${message.author.tag} (ID: ${message.author.id}) - not owner or admin`);
                     return;
                 }
-                voiceLogger.log(`[AUTHORIZED] Message from ${message.author.tag} (Owner: ${isOwner}, Admin: ${isAdmin})`);
             }
             const channel = message.channel;
             const isThread = [
@@ -1568,12 +1589,14 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     messageContent = transcription;
                 }
                 const images = getImageAttachments(message);
+                const parsedCommand = parseSlashCommand(messageContent);
                 await handleOpencodeSession({
                     prompt: messageContent,
                     thread,
                     projectDirectory,
                     originalMessage: message,
                     images,
+                    parsedCommand,
                 });
                 return;
             }
@@ -1634,12 +1657,14 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                     messageContent = transcription;
                 }
                 const images = getImageAttachments(message);
+                const parsedCommand = parseSlashCommand(messageContent);
                 await handleOpencodeSession({
                     prompt: messageContent,
                     thread,
                     projectDirectory,
                     originalMessage: message,
                     images,
+                    parsedCommand,
                 });
             }
             else {
@@ -1895,10 +1920,12 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                         await command.editReply(`Created new session in ${thread.toString()}`);
                         // Start the OpenCode session
+                        const parsedCommand = parseSlashCommand(fullPrompt);
                         await handleOpencodeSession({
                             prompt: fullPrompt,
                             thread,
                             projectDirectory,
+                            parsedCommand,
                         });
                     }
                     catch (error) {
@@ -2167,6 +2194,68 @@ export async function startDiscordBot({ token, appId, discordClient, }) {
                         });
                     }
                 }
+                else if (command.commandName === 'abort') {
+                    const channel = command.channel;
+                    if (!channel) {
+                        await command.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 command.reply({
+                            content: 'This command can only be used in a thread with an active session',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    const textChannel = resolveTextChannel(channel);
+                    const { projectDirectory: directory } = getKimakiMetadata(textChannel);
+                    if (!directory) {
+                        await command.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 command.reply({
+                            content: 'No active session in this thread',
+                            ephemeral: true,
+                        });
+                        return;
+                    }
+                    const sessionId = row.session_id;
+                    try {
+                        const existingController = abortControllers.get(sessionId);
+                        if (existingController) {
+                            existingController.abort(new Error('User requested abort'));
+                            abortControllers.delete(sessionId);
+                        }
+                        const getClient = await initializeOpencodeForDirectory(directory);
+                        await getClient().session.abort({
+                            path: { id: sessionId },
+                        });
+                        await command.reply(`🛑 Request **aborted**`);
+                        sessionLogger.log(`Session ${sessionId} aborted by user`);
+                    }
+                    catch (error) {
+                        voiceLogger.error('[ABORT] Error:', error);
+                        await command.reply({
+                            content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                            ephemeral: true,
+                        });
+                    }
+                }
             }
         }
         catch (error) {

package/dist/tools.js

@@ -8,7 +8,7 @@ const toolsLogger = createLogger('TOOLS');
 import { formatDistanceToNow } from 'date-fns';
 import { ShareMarkdown } from './markdown.js';
 import pc from 'picocolors';
-import { initializeOpencodeForDirectory, OPENCODE_SYSTEM_MESSAGE, } from './discordBot.js';
+import { initializeOpencodeForDirectory, getOpencodeSystemMessage, } from './discordBot.js';
 export async function getTools({ onMessageCompleted, directory, }) {
     const getClient = await initializeOpencodeForDirectory(directory);
     const client = getClient();
@@ -48,7 +48,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                     body: {
                         parts: [{ type: 'text', text: message }],
                         model: sessionModel,
-                        system: OPENCODE_SYSTEM_MESSAGE,
+                        system: getOpencodeSystemMessage({ sessionId }),
                     },
                 })
                     .then(async (response) => {
@@ -115,7 +115,7 @@ export async function getTools({ onMessageCompleted, directory, }) {
                         path: { id: session.data.id },
                         body: {
                             parts: [{ type: 'text', text: message }],
-                            system: OPENCODE_SYSTEM_MESSAGE,
+                            system: getOpencodeSystemMessage({ sessionId: session.data.id }),
                         },
                     })
                         .then(async (response) => {

package/package.json

@@ -2,17 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.13",
-  "scripts": {
-    "dev": "tsx --env-file .env src/cli.ts",
-    "prepublishOnly": "pnpm tsc",
-    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
-    "watch": "tsx scripts/watch-session.ts",
-    "test:events": "tsx test-events.ts",
-    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
-    "test:send": "tsx send-test-message.ts",
-    "register-commands": "tsx scripts/register-commands.ts"
-  },
+  "version": "0.4.14",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -54,5 +44,14 @@
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "zod": "^4.0.17"
+  },
+  "scripts": {
+    "dev": "tsx --env-file .env src/cli.ts",
+    "dev:bun": "DEBUG=1 bun --env-file .env src/cli.ts",
+    "watch": "tsx scripts/watch-session.ts",
+    "test:events": "tsx test-events.ts",
+    "pcm-to-mp3": "bun scripts/pcm-to-mp3",
+    "test:send": "tsx send-test-message.ts",
+    "register-commands": "tsx scripts/register-commands.ts"
   }
-}
+}