kimaki 0.4.24 → 0.4.25

package/dist/logger.js

@@ -1,3 +1,6 @@
+// Prefixed logging utility using @clack/prompts.
+// Creates loggers with consistent prefixes for different subsystems
+// (DISCORD, VOICE, SESSION, etc.) for easier debugging.
 import { log } from '@clack/prompts';
 export function createLogger(prefix) {
     return {

package/dist/markdown.js

@@ -1,3 +1,6 @@
+// Session-to-markdown renderer for sharing.
+// Generates shareable markdown from OpenCode sessions, formatting
+// user messages, assistant responses, tool calls, and reasoning blocks.
 import * as yaml from 'js-yaml';
 import { formatDateTime } from './utils.js';
 import { extractNonXmlContent } from './xml.js';

package/dist/message-formatting.js

@@ -1,5 +1,30 @@
+// OpenCode message part formatting for Discord.
+// Converts SDK message parts (text, tools, reasoning) to Discord-friendly format,
+// handles file attachments, and provides tool summary generation.
 import { createLogger } from './logger.js';
 const logger = createLogger('FORMATTING');
+/**
+ * Collects and formats the last N assistant parts from session messages.
+ * Used by both /resume and /fork to show recent assistant context.
+ */
+export function collectLastAssistantParts({ messages, limit = 30, }) {
+    const allAssistantParts = [];
+    for (const message of messages) {
+        if (message.info.role === 'assistant') {
+            for (const part of message.parts) {
+                const content = formatPart(part);
+                if (content.trim()) {
+                    allAssistantParts.push({ id: part.id, content: content.trimEnd() });
+                }
+            }
+        }
+    }
+    const partsToRender = allAssistantParts.slice(-limit);
+    const partIds = partsToRender.map((p) => p.id);
+    const content = partsToRender.map((p) => p.content).join('\n');
+    const skippedCount = allAssistantParts.length - partsToRender.length;
+    return { partIds, content, skippedCount };
+}
 export const TEXT_MIME_TYPES = [
     'text/',
     'application/json',
@@ -108,7 +133,7 @@ export function getToolSummaryText(part) {
         if (value === null || value === undefined)
             return null;
         const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
-        const truncatedValue = stringValue.length > 300 ? stringValue.slice(0, 300) + '…' : stringValue;
+        const truncatedValue = stringValue.length > 50 ? stringValue.slice(0, 50) + '…' : stringValue;
         return `${key}: ${truncatedValue}`;
     })
         .filter(Boolean);
@@ -130,12 +155,14 @@ export function formatTodoList(part) {
 }
 export function formatPart(part) {
     if (part.type === 'text') {
-        return part.text || '';
+        if (!part.text?.trim())
+            return '';
+        return `⬥ ${part.text}`;
     }
     if (part.type === 'reasoning') {
         if (!part.text?.trim())
             return '';
-        return `◼︎ thinking`;
+        return `┣ thinking`;
     }
     if (part.type === 'file') {
         return `📄 ${part.filename || 'File'}`;
@@ -144,10 +171,10 @@ export function formatPart(part) {
         return '';
     }
     if (part.type === 'agent') {
-        return `◼︎ agent ${part.id}`;
+        return `┣ agent ${part.id}`;
     }
     if (part.type === 'snapshot') {
-        return `◼︎ snapshot ${part.snapshot}`;
+        return `┣ snapshot ${part.snapshot}`;
     }
     if (part.type === 'tool') {
         if (part.tool === 'todowrite') {
@@ -180,7 +207,15 @@ export function formatPart(part) {
         else if (stateTitle) {
             toolTitle = `_${stateTitle}_`;
         }
-        const icon = part.state.status === 'error' ? '⨯' : '◼︎';
+        const icon = (() => {
+            if (part.state.status === 'error') {
+                return '⨯';
+            }
+            if (part.tool === 'edit' || part.tool === 'write') {
+                return '◼︎';
+            }
+            return '┣';
+        })();
         return `${icon} ${part.tool} ${toolTitle} ${summaryText}`;
     }
     logger.warn('Unknown part type:', part);

package/dist/opencode.js

@@ -1,3 +1,6 @@
+// OpenCode server process manager.
+// Spawns and maintains OpenCode API servers per project directory,
+// handles automatic restarts on failure, and provides typed SDK clients.
 import { spawn } from 'node:child_process';
 import net from 'node:net';
 import { createOpencodeClient, } from '@opencode-ai/sdk';

package/dist/session-handler.js

@@ -1,7 +1,10 @@
+// OpenCode session lifecycle manager.
+// Creates, maintains, and sends prompts to OpenCode sessions from Discord threads.
+// Handles streaming events, permissions, abort signals, and message queuing.
 import prettyMilliseconds from 'pretty-ms';
 import { getDatabase, getSessionModel, getChannelModel } from './database.js';
 import { initializeOpencodeForDirectory, getOpencodeServers } from './opencode.js';
-import { sendThreadMessage } from './discord-utils.js';
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from './discord-utils.js';
 import { formatPart } from './message-formatting.js';
 import { getOpencodeSystemMessage } from './system-message.js';
 import { createLogger } from './logger.js';
@@ -24,6 +27,21 @@ export function parseSlashCommand(text) {
 }
 export const abortControllers = new Map();
 export const pendingPermissions = new Map();
+// Queue of messages waiting to be sent after current response finishes
+// Key is threadId, value is array of queued messages
+export const messageQueue = new Map();
+export function addToQueue({ threadId, message, }) {
+    const queue = messageQueue.get(threadId) || [];
+    queue.push(message);
+    messageQueue.set(threadId, queue);
+    return queue.length;
+}
+export function getQueueLength(threadId) {
+    return messageQueue.get(threadId)?.length || 0;
+}
+export function clearQueue(threadId) {
+    messageQueue.delete(threadId);
+}
 export async function handleOpencodeSession({ prompt, thread, projectDirectory, originalMessage, images = [], parsedCommand, channelId, }) {
     voiceLogger.log(`[OPENCODE SESSION] Starting for thread ${thread.id} with prompt: "${prompt.slice(0, 50)}${prompt.length > 50 ? '...' : ''}"`);
     const sessionStartTime = Date.now();
@@ -212,7 +230,7 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                                 const thresholdCrossed = Math.floor(currentPercentage / 10) * 10;
                                 if (thresholdCrossed > lastDisplayedContextPercentage && thresholdCrossed >= 10) {
                                     lastDisplayedContextPercentage = thresholdCrossed;
-                                    await sendThreadMessage(thread, `◼︎ context usage ${currentPercentage}%`);
+                                    await sendThreadMessage(thread, `⬥ context usage ${currentPercentage}%`);
                                 }
                             }
                         }
@@ -353,8 +371,34 @@ export async function handleOpencodeSession({ prompt, thread, projectDirectory,
                 catch (e) {
                     sessionLogger.error('Failed to fetch provider info for context percentage:', e);
                 }
-                await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`);
+                await sendThreadMessage(thread, `_Completed in ${sessionDuration}${contextInfo}_${attachCommand}${modelInfo}`, { flags: NOTIFY_MESSAGE_FLAGS });
                 sessionLogger.log(`DURATION: Session completed in ${sessionDuration}, port ${port}, model ${usedModel}, tokens ${tokensUsedInSession}`);
+                // Process queued messages after completion
+                const queue = messageQueue.get(thread.id);
+                if (queue && queue.length > 0) {
+                    const nextMessage = queue.shift();
+                    if (queue.length === 0) {
+                        messageQueue.delete(thread.id);
+                    }
+                    sessionLogger.log(`[QUEUE] Processing queued message from ${nextMessage.username}`);
+                    // Show that queued message is being sent
+                    await sendThreadMessage(thread, `» **${nextMessage.username}:** ${nextMessage.prompt.slice(0, 150)}${nextMessage.prompt.length > 150 ? '...' : ''}`);
+                    // Send the queued message as a new prompt (recursive call)
+                    // Use setImmediate to avoid blocking and allow this finally to complete
+                    setImmediate(() => {
+                        handleOpencodeSession({
+                            prompt: nextMessage.prompt,
+                            thread,
+                            projectDirectory,
+                            images: nextMessage.images,
+                            channelId,
+                        }).catch(async (e) => {
+                            sessionLogger.error(`[QUEUE] Failed to process queued message:`, e);
+                            const errorMsg = e instanceof Error ? e.message : String(e);
+                            await sendThreadMessage(thread, `✗ Queued message failed: ${errorMsg.slice(0, 200)}`);
+                        });
+                    });
+                }
             }
             else {
                 sessionLogger.log(`Session was aborted (reason: ${abortController.signal.reason}), skipping duration message`);

package/dist/system-message.js

@@ -1,3 +1,6 @@
+// OpenCode system prompt generator.
+// Creates the system message injected into every OpenCode session,
+// including Discord-specific formatting rules, diff commands, and permissions info.
 export function getOpencodeSystemMessage({ sessionId }) {
     return `
 The user is reading your messages from inside Discord, via kimaki.xyz
@@ -66,6 +69,19 @@ the max heading level is 3, so do not use ####
 
 headings are discouraged anyway. instead try to use bold text for titles which renders more nicely in Discord
 
+## capitalization
+
+write casually like a discord user. never capitalize the initials of phrases or acronyms in your messages. use all lowercase instead.
+
+examples:
+- write "api" not "API"
+- write "url" not "URL"
+- write "json" not "JSON"
+- write "cli" not "CLI"
+- write "sdk" not "SDK"
+
+this makes your messages blend in naturally with how people actually type on discord.
+
 ## tables
 
 discord does NOT support markdown gfm tables.

package/dist/tools.js

@@ -1,3 +1,6 @@
+// Voice assistant tool definitions for the GenAI worker.
+// Provides tools for managing OpenCode sessions (create, submit, abort),
+// listing chats, searching files, and reading session messages.
 import { tool } from 'ai';
 import { z } from 'zod';
 import { spawn } from 'node:child_process';

package/dist/utils.js

@@ -1,3 +1,6 @@
+// General utility functions for the bot.
+// Includes Discord OAuth URL generation, array deduplication,
+// abort error detection, and date/time formatting helpers.
 import { PermissionsBitField } from 'discord.js';
 export function generateBotInstallUrl({ clientId, permissions = [
     PermissionsBitField.Flags.ViewChannel,

package/dist/voice-handler.js

@@ -1,3 +1,6 @@
+// Discord voice channel connection and audio stream handler.
+// Manages joining/leaving voice channels, captures user audio, resamples to 16kHz,
+// and routes audio to the GenAI worker for real-time voice assistant interactions.
 import { VoiceConnectionStatus, EndBehaviorType, joinVoiceChannel, entersState, } from '@discordjs/voice';
 import { exec } from 'node:child_process';
 import fs, { createWriteStream } from 'node:fs';

package/dist/voice.js

@@ -1,3 +1,6 @@
+// Audio transcription service using Google Gemini.
+// Transcribes voice messages with code-aware context, using grep/glob tools
+// to verify technical terms, filenames, and function names in the codebase.
 import { GoogleGenAI, Type, } from '@google/genai';
 import { createLogger } from './logger.js';
 import { glob } from 'glob';

package/dist/worker-types.js

@@ -1 +1,4 @@
+// Type definitions for worker thread message passing.
+// Defines the protocol between main thread and GenAI worker for
+// audio streaming, tool calls, and session lifecycle management.
 export {};

package/dist/xml.js

@@ -1,3 +1,6 @@
+// XML/HTML tag content extractor.
+// Parses XML-like tags from strings (e.g., channel topics) to extract
+// Kimaki configuration like directory paths and app IDs.
 import { DomHandler, Parser, ElementType } from 'htmlparser2';
 import { createLogger } from './logger.js';
 const xmlLogger = createLogger('XML');

package/package.json

@@ -2,17 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.24",
-  "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.25",
   "repository": "https://github.com/remorses/kimaki",
   "bin": "bin.js",
   "files": [
@@ -55,5 +45,14 @@
     "string-dedent": "^3.0.2",
     "undici": "^7.16.0",
     "zod": "^4.2.1"
+  },
+  "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"
   }
-}
+}

package/src/ai-tool-to-genai.ts

@@ -1,3 +1,7 @@
+// AI SDK to Google GenAI tool converter.
+// Transforms Vercel AI SDK tool definitions into Google GenAI CallableTool format
+// for use with Gemini's function calling in the voice assistant.
+
 import type { Tool, jsonSchema as JsonSchemaType } from 'ai'
 import type {
   FunctionDeclaration,

package/src/channel-management.ts

@@ -1,3 +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,
   type CategoryChannel,

package/src/cli.ts

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+// Main CLI entrypoint for the Kimaki Discord bot.
+// Handles interactive setup, Discord OAuth, slash command registration,
+// project channel creation, and launching the bot with opencode integration.
 import { cac } from 'cac'
 import {
   intro,
@@ -50,31 +53,83 @@ process.title = 'kimaki'
 
 const LOCK_PORT = 29988
 
+async function killProcessOnPort(port: number): Promise<boolean> {
+  const isWindows = process.platform === 'win32'
+  const myPid = process.pid
+
+  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`], {
+        shell: false,
+        encoding: 'utf-8',
+      })
+      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) {
+        cliLogger.log(`Killing existing kimaki process (PID: ${targetPid})`)
+        spawnSync('taskkill', ['/F', '/PID', targetPid], { shell: false })
+        return true
+      }
+    } else {
+      // Unix: use lsof with -sTCP:LISTEN to only find the listening process
+      const result = spawnSync('lsof', ['-i', `:${port}`, '-sTCP:LISTEN', '-t'], {
+        shell: false,
+        encoding: 'utf-8',
+      })
+      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) {
+        cliLogger.log(`Killing existing kimaki process (PID: ${targetPid})`)
+        process.kill(parseInt(targetPid, 10), 'SIGKILL')
+        return true
+      }
+    }
+  } catch {
+    // Failed to kill, continue anyway
+  }
+  return false
+}
+
 async function checkSingleInstance(): Promise<void> {
   try {
     const response = await fetch(`http://127.0.0.1:${LOCK_PORT}`, {
       signal: AbortSignal.timeout(1000),
     })
     if (response.ok) {
-      cliLogger.error('Another kimaki instance is already running')
-      process.exit(1)
+      cliLogger.log('Another kimaki instance detected')
+      await killProcessOnPort(LOCK_PORT)
+      // Wait a moment for port to be released
+      await new Promise((resolve) => { setTimeout(resolve, 500) })
     }
   } catch {
     // Connection refused means no instance running, continue
   }
 }
 
-function startLockServer(): void {
-  const server = http.createServer((req, res) => {
-    res.writeHead(200)
-    res.end('kimaki')
-  })
-  server.listen(LOCK_PORT, '127.0.0.1')
-  server.on('error', (err: NodeJS.ErrnoException) => {
-    if (err.code === 'EADDRINUSE') {
-      cliLogger.error('Another kimaki instance is already running')
-      process.exit(1)
-    }
+async function startLockServer(): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      res.writeHead(200)
+      res.end('kimaki')
+    })
+    server.listen(LOCK_PORT, '127.0.0.1')
+    server.once('listening', () => {
+      resolve()
+    })
+    server.on('error', async (err: NodeJS.ErrnoException) => {
+      if (err.code === 'EADDRINUSE') {
+        cliLogger.log('Port still in use, retrying...')
+        await killProcessOnPort(LOCK_PORT)
+        await new Promise((r) => { setTimeout(r, 500) })
+        // Retry once
+        server.listen(LOCK_PORT, '127.0.0.1')
+      } else {
+        reject(err)
+      }
+    })
   })
 }
 
@@ -188,6 +243,30 @@ async function registerCommands(token: string, appId: string) {
       .setName('model')
       .setDescription('Set the preferred model for this channel or session')
       .toJSON(),
+    new SlashCommandBuilder()
+      .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)
+
+        return option
+      })
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('clear-queue')
+      .setDescription('Clear all queued messages in this thread')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('undo')
+      .setDescription('Undo the last assistant message (revert file changes)')
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName('redo')
+      .setDescription('Redo previously undone changes')
+      .toJSON(),
   ]
 
   const rest = new REST().setToken(token)
@@ -693,7 +772,7 @@ cli
   .action(async (options: { restart?: boolean; addChannels?: boolean }) => {
     try {
       await checkSingleInstance()
-      startLockServer()
+      await startLockServer()
       await run({
         restart: options.restart,
         addChannels: options.addChannels,

package/src/commands/abort.ts

@@ -0,0 +1,94 @@
+// /abort command - Abort the current OpenCode request in this thread.
+
+import { ChannelType, type ThreadChannel } from 'discord.js'
+import type { CommandContext } from './types.js'
+import { getDatabase } from '../database.js'
+import { initializeOpencodeForDirectory } from '../opencode.js'
+import { resolveTextChannel, getKimakiMetadata, SILENT_MESSAGE_FLAGS } from '../discord-utils.js'
+import { abortControllers } from '../session-handler.js'
+import { createLogger } from '../logger.js'
+
+const logger = createLogger('ABORT')
+
+export async function handleAbortCommand({
+  command,
+}: CommandContext): Promise<void> {
+  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 as ThreadChannel)
+  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) as { session_id: string } | undefined
+
+  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 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({
+      content: `🛑 Request **aborted**`,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+    logger.log(`Session ${sessionId} aborted by user`)
+  } catch (error) {
+    logger.error('[ABORT] Error:', error)
+    await command.reply({
+      content: `Failed to abort: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      ephemeral: true,
+      flags: SILENT_MESSAGE_FLAGS,
+    })
+  }
+}