kimaki 0.4.30 → 0.4.32

package/dist/unnest-code-blocks.test.js

@@ -0,0 +1,213 @@
+import { test, expect } from 'vitest';
+import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js';
+test('basic - single item with code block', () => {
+    const input = `- Item 1
+  \`\`\`js
+  const x = 1
+  \`\`\``;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- Item 1
+
+    \`\`\`js
+    const x = 1
+    \`\`\`
+    "
+  `);
+});
+test('multiple items - code in middle item only', () => {
+    const input = `- Item 1
+- Item 2
+  \`\`\`js
+  const x = 1
+  \`\`\`
+- Item 3`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- Item 1
+    - Item 2
+
+    \`\`\`js
+    const x = 1
+    \`\`\`
+    - Item 3"
+  `);
+});
+test('multiple code blocks in one item', () => {
+    const input = `- Item with two code blocks
+  \`\`\`js
+  const a = 1
+  \`\`\`
+  \`\`\`python
+  b = 2
+  \`\`\``;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- Item with two code blocks
+
+    \`\`\`js
+    const a = 1
+    \`\`\`
+    \`\`\`python
+    b = 2
+    \`\`\`
+    "
+  `);
+});
+test('nested list with code', () => {
+    const input = `- Item 1
+  - Nested item
+    \`\`\`js
+    const x = 1
+    \`\`\`
+- Item 2`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- Item 1
+    - Nested item
+
+    \`\`\`js
+    const x = 1
+    \`\`\`
+    - Item 2"
+  `);
+});
+test('ordered list preserves numbering', () => {
+    const input = `1. First item
+   \`\`\`js
+   const a = 1
+   \`\`\`
+2. Second item
+3. Third item`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "1. First item
+
+    \`\`\`js
+    const a = 1
+    \`\`\`
+    2. Second item
+    3. Third item"
+  `);
+});
+test('list without code blocks unchanged', () => {
+    const input = `- Item 1
+- Item 2
+- Item 3`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- Item 1
+    - Item 2
+    - Item 3"
+  `);
+});
+test('mixed - some items have code, some dont', () => {
+    const input = `- Normal item
+- Item with code
+  \`\`\`js
+  const x = 1
+  \`\`\`
+- Another normal item
+- Another with code
+  \`\`\`python
+  y = 2
+  \`\`\``;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- Normal item
+    - Item with code
+
+    \`\`\`js
+    const x = 1
+    \`\`\`
+    - Another normal item
+    - Another with code
+
+    \`\`\`python
+    y = 2
+    \`\`\`
+    "
+  `);
+});
+test('text before and after code in same item', () => {
+    const input = `- Start text
+  \`\`\`js
+  const x = 1
+  \`\`\`
+  End text`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- Start text
+
+    \`\`\`js
+    const x = 1
+    \`\`\`
+    - End text
+    "
+  `);
+});
+test('preserves content outside lists', () => {
+    const input = `# Heading
+
+Some paragraph text.
+
+- List item
+  \`\`\`js
+  const x = 1
+  \`\`\`
+
+More text after.`;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "# Heading
+
+    Some paragraph text.
+
+    - List item
+
+    \`\`\`js
+    const x = 1
+    \`\`\`
+
+
+    More text after."
+  `);
+});
+test('code block at root level unchanged', () => {
+    const input = `\`\`\`js
+const x = 1
+\`\`\``;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "\`\`\`js
+    const x = 1
+    \`\`\`"
+  `);
+});
+test('handles code block without language', () => {
+    const input = `- Item
+  \`\`\`
+  plain code
+  \`\`\``;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "- Item
+
+    \`\`\`
+    plain code
+    \`\`\`
+    "
+  `);
+});
+test('handles empty list item with code', () => {
+    const input = `- \`\`\`js
+  const x = 1
+  \`\`\``;
+    const result = unnestCodeBlocksFromLists(input);
+    expect(result).toMatchInlineSnapshot(`
+    "\`\`\`js
+    const x = 1
+    \`\`\`
+    "
+  `);
+});

package/dist/utils.js

@@ -17,6 +17,7 @@ export function generateBotInstallUrl({ clientId, permissions = [
     PermissionsBitField.Flags.AttachFiles,
     PermissionsBitField.Flags.Connect,
     PermissionsBitField.Flags.Speak,
+    PermissionsBitField.Flags.ManageRoles,
 ], scopes = ['bot'], guildId, disableGuildSelect = false, }) {
     const permissionsBitField = new PermissionsBitField(permissions);
     const permissionsValue = permissionsBitField.bitfield.toString();

package/package.json

@@ -2,7 +2,7 @@
   "name": "kimaki",
   "module": "index.ts",
   "type": "module",
-  "version": "0.4.30",
+  "version": "0.4.32",
   "scripts": {
     "dev": "tsx --env-file .env src/cli.ts",
     "prepublishOnly": "pnpm tsc",

package/src/cli.ts

@@ -529,8 +529,14 @@ async function run({ restart, addChannels }: CliOptions) {
   }
 
   const s = spinner()
-  s.start('Creating Discord client and connecting...')
 
+  // Start OpenCode server EARLY - let it initialize in parallel with Discord login.
+  // This is the biggest startup bottleneck (can take 1-30 seconds to spawn and wait for ready)
+  const currentDir = process.cwd()
+  s.start('Starting OpenCode server...')
+  const opencodePromise = initializeOpencodeForDirectory(currentDir)
+
+  s.message('Connecting to Discord...')
   const discordClient = await createDiscordClient()
 
   const guilds: Guild[] = []
@@ -542,15 +548,56 @@ async function run({ restart, addChannels }: CliOptions) {
       discordClient.once(Events.ClientReady, async (c) => {
         guilds.push(...Array.from(c.guilds.cache.values()))
 
-        for (const guild of guilds) {
-          const channels = await getChannelsWithDescriptions(guild)
-          const kimakiChans = channels.filter(
-            (ch) =>
-              ch.kimakiDirectory && (!ch.kimakiApp || ch.kimakiApp === appId),
-          )
+        // Process all guilds in parallel for faster startup
+        const guildResults = await Promise.all(
+          guilds.map(async (guild) => {
+            // Create Kimaki role if it doesn't exist, or fix its position (fire-and-forget)
+            guild.roles
+              .fetch()
+              .then(async (roles) => {
+                const existingRole = roles.find(
+                  (role) => role.name.toLowerCase() === 'kimaki',
+                )
+                if (existingRole) {
+                  // Move to bottom if not already there
+                  if (existingRole.position > 1) {
+                    await existingRole.setPosition(1)
+                    cliLogger.info(`Moved "Kimaki" role to bottom in ${guild.name}`)
+                  }
+                  return
+                }
+                return guild.roles.create({
+                  name: 'Kimaki',
+                  position: 1, // Place at bottom so anyone with Manage Roles can assign it
+                  reason:
+                    'Kimaki bot permission role - assign to users who can start sessions, send messages in threads, and use voice features',
+                })
+              })
+              .then((role) => {
+                if (role) {
+                  cliLogger.info(`Created "Kimaki" role in ${guild.name}`)
+                }
+              })
+              .catch((error) => {
+                cliLogger.warn(
+                  `Could not create Kimaki role in ${guild.name}: ${error instanceof Error ? error.message : String(error)}`,
+                )
+              })
+
+            const channels = await getChannelsWithDescriptions(guild)
+            const kimakiChans = channels.filter(
+              (ch) =>
+                ch.kimakiDirectory && (!ch.kimakiApp || ch.kimakiApp === appId),
+            )
+
+            return { guild, channels: kimakiChans }
+          }),
+        )
 
-          if (kimakiChans.length > 0) {
-            kimakiChannels.push({ guild, channels: kimakiChans })
+        // Collect results
+        for (const result of guildResults) {
+          if (result.channels.length > 0) {
+            kimakiChannels.push(result)
           }
         }
 
@@ -613,32 +660,25 @@ async function run({ restart, addChannels }: CliOptions) {
     note(channelList, 'Existing Kimaki Channels')
   }
 
-  s.start('Starting OpenCode server...')
-
-  const currentDir = process.cwd()
-  let getClient = await initializeOpencodeForDirectory(currentDir)
-  s.stop('OpenCode server started!')
+  // Await the OpenCode server that was started in parallel with Discord login
+  s.start('Waiting for OpenCode server...')
+  const getClient = await opencodePromise
+  s.stop('OpenCode server ready!')
 
-  s.start('Fetching OpenCode projects...')
+  s.start('Fetching OpenCode data...')
 
-  let projects: Project[] = []
+  // Fetch projects and commands in parallel
+  const [projects, allUserCommands] = await Promise.all([
+    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(() => []),
+  ])
 
-  try {
-    const projectsResponse = await getClient().project.list({})
-    if (!projectsResponse.data) {
-      throw new Error('Failed to fetch projects')
-    }
-    projects = projectsResponse.data
-    s.stop(`Found ${projects.length} OpenCode project(s)`)
-  } 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)
-  }
+  s.stop(`Found ${projects.length} OpenCode project(s)`)
 
   const existingDirs = kimakiChannels.flatMap(({ channels }) =>
     channels
@@ -746,19 +786,6 @@ async function run({ restart, addChannels }: CliOptions) {
     }
   }
 
-  // Fetch user-defined commands using the already-running server
-  const allUserCommands: OpencodeCommand[] = []
-  try {
-    const commandsResponse = await getClient().command.list({
-      query: { directory: currentDir },
-    })
-    if (commandsResponse.data) {
-      allUserCommands.push(...commandsResponse.data)
-    }
-  } catch {
-    // Ignore errors fetching commands
-  }
-
   // Log available user commands
   const registrableCommands = allUserCommands.filter(
     (cmd) => !SKIP_USER_COMMANDS.includes(cmd.name),
@@ -839,13 +866,31 @@ cli
     '--data-dir <path>',
     'Data directory for config and database (default: ~/.kimaki)',
   )
-  .action(async (options: { restart?: boolean; addChannels?: boolean; dataDir?: string }) => {
+  .option('--install-url', 'Print the bot install URL and exit')
+  .action(async (options: { restart?: boolean; addChannels?: boolean; dataDir?: string; installUrl?: boolean }) => {
     try {
       // Set data directory early, before any database access
       if (options.dataDir) {
         setDataDir(options.dataDir)
         cliLogger.log(`Using data directory: ${getDataDir()}`)
       }
+
+      if (options.installUrl) {
+        const db = getDatabase()
+        const existingBot = db
+          .prepare(
+            'SELECT app_id FROM bot_tokens ORDER BY created_at DESC LIMIT 1',
+          )
+          .get() as { app_id: string } | undefined
+
+        if (!existingBot) {
+          cliLogger.error('No bot configured yet. Run `kimaki` first to set up.')
+          process.exit(EXIT_NO_RESTART)
+        }
+
+        console.log(generateBotInstallUrl({ clientId: existingBot.app_id }))
+        process.exit(0)
+      }
       
       await checkSingleInstance()
       await startLockServer()

package/src/commands/ask-question.ts

@@ -10,7 +10,7 @@ import {
 } from 'discord.js'
 import crypto from 'node:crypto'
 import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from '../discord-utils.js'
-import { getOpencodeServerPort } from '../opencode.js'
+import { getOpencodeClientV2 } from '../opencode.js'
 import { createLogger } from '../logger.js'
 
 const logger = createLogger('ASK_QUESTION')
@@ -200,31 +200,20 @@ async function submitQuestionAnswers(
   context: PendingQuestionContext
 ): Promise<void> {
   try {
-    // Build answers array: each element is an array of selected labels for that question
-    const answersPayload = context.questions.map((_, i) => {
-      return context.answers[i] || []
-    })
-
-    // Reply to the question using direct HTTP call to OpenCode API
-    // (v1 SDK doesn't have question.reply, so we call it directly)
-    const port = getOpencodeServerPort(context.directory)
-    if (!port) {
+    const clientV2 = getOpencodeClientV2(context.directory)
+    if (!clientV2) {
       throw new Error('OpenCode server not found for directory')
     }
 
-    const response = await fetch(
-      `http://127.0.0.1:${port}/question/${context.requestId}/reply`,
-      {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ answers: answersPayload }),
-      }
-    )
+    // Build answers array: each element is an array of selected labels for that question
+    const answers = context.questions.map((_, i) => {
+      return context.answers[i] || []
+    })
 
-    if (!response.ok) {
-      const text = await response.text()
-      throw new Error(`Failed to reply to question: ${response.status} ${text}`)
-    }
+    await clientV2.question.reply({
+      requestID: context.requestId,
+      answers,
+    })
 
     logger.log(`Submitted answers for question ${context.requestId} in session ${context.sessionId}`)
   } catch (error) {
@@ -275,3 +264,49 @@ export function parseAskUserQuestionTool(part: {
 
   return input
 }
+
+/**
+ * Cancel a pending question for a thread (e.g., when user sends a new message).
+ * Sends cancellation response to OpenCode so the session can continue.
+ */
+export async function cancelPendingQuestion(threadId: string): Promise<boolean> {
+  // Find pending question for this thread
+  let contextHash: string | undefined
+  let context: PendingQuestionContext | undefined
+  for (const [hash, ctx] of pendingQuestionContexts) {
+    if (ctx.thread.id === threadId) {
+      contextHash = hash
+      context = ctx
+      break
+    }
+  }
+
+  if (!contextHash || !context) {
+    return false
+  }
+
+  try {
+    const clientV2 = getOpencodeClientV2(context.directory)
+    if (!clientV2) {
+      throw new Error('OpenCode server not found for directory')
+    }
+
+    // Preserve already-answered questions, mark unanswered as cancelled
+    const answers = context.questions.map((_, i) => {
+      return context.answers[i] || ['(cancelled - user sent new message)']
+    })
+
+    await clientV2.question.reply({
+      requestID: context.requestId,
+      answers,
+    })
+
+    logger.log(`Cancelled question ${context.requestId} due to new user message`)
+  } catch (error) {
+    logger.error('Failed to cancel question:', error)
+  }
+
+  // Clean up regardless of whether the API call succeeded
+  pendingQuestionContexts.delete(contextHash)
+  return true
+}

package/src/discord-bot.ts

@@ -180,7 +180,10 @@ export async function startDiscordBot({
         )
 
         if (!isOwner && !isAdmin && !canManageServer && !hasKimakiRole) {
-          await message.react('🔒')
+          await message.reply({
+            content: `You don't have permission to start sessions.\nTo use Kimaki, ask a server admin to give you the **Kimaki** role.`,
+            flags: SILENT_MESSAGE_FLAGS,
+          })
           return
         }
       }

package/src/discord-utils.ts

@@ -11,6 +11,7 @@ import {
 import { Lexer } from 'marked'
 import { extractTagsArrays } from './xml.js'
 import { formatMarkdownTables } from './format-tables.js'
+import { unnestCodeBlocksFromLists } from './unnest-code-blocks.js'
 import { createLogger } from './logger.js'
 
 const discordLogger = createLogger('DISCORD')
@@ -125,7 +126,8 @@ export function splitMarkdownForDiscord({
 
         // calculate overhead for code block markers
         const codeBlockOverhead = line.inCodeBlock ? ('```' + line.lang + '\n').length + '```\n'.length : 0
-        const availablePerChunk = maxLength - codeBlockOverhead - 50 // safety margin
+        // ensure at least 10 chars available, even if maxLength is very small
+        const availablePerChunk = Math.max(10, maxLength - codeBlockOverhead - 50)
 
         const pieces = splitLongLine(line.text, availablePerChunk, line.inCodeBlock)
 
@@ -198,6 +200,7 @@ export async function sendThreadMessage(
   const MAX_LENGTH = 2000
 
   content = formatMarkdownTables(content)
+  content = unnestCodeBlocksFromLists(content)
   content = escapeBackticksInCodeBlocks(content)
 
   // If custom flags provided, send as single message (no chunking)

package/src/escape-backticks.test.ts

@@ -376,11 +376,19 @@ test('splitMarkdownForDiscord handles very long line inside code block', () => {
     \`\`\`
     ",
       "\`\`\`js
-    veryverylonglinethatexceedsmaxlength
-    \`\`\`
+    veryverylo\`\`\`
     ",
       "\`\`\`js
-    short
+    nglinethat\`\`\`
+    ",
+      "\`\`\`js
+    exceedsmax\`\`\`
+    ",
+      "\`\`\`js
+    length
+    \`\`\`
+    ",
+      "short
     \`\`\`
     ",
     ]

package/src/session-handler.ts

@@ -8,12 +8,12 @@ import type { Message, ThreadChannel } from 'discord.js'
 import prettyMilliseconds from 'pretty-ms'
 import { getDatabase, getSessionModel, getChannelModel, getSessionAgent, getChannelAgent } from './database.js'
 import { initializeOpencodeForDirectory, getOpencodeServers, getOpencodeClientV2 } from './opencode.js'
-import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS } from './discord-utils.js'
+import { sendThreadMessage, NOTIFY_MESSAGE_FLAGS, SILENT_MESSAGE_FLAGS } from './discord-utils.js'
 import { formatPart } from './message-formatting.js'
 import { getOpencodeSystemMessage } from './system-message.js'
 import { createLogger } from './logger.js'
 import { isAbortError } from './utils.js'
-import { showAskUserQuestionDropdowns } from './commands/ask-question.js'
+import { showAskUserQuestionDropdowns, cancelPendingQuestion } from './commands/ask-question.js'
 import { showPermissionDropdown, cleanupPermissionContext } from './commands/permissions.js'
 
 const sessionLogger = createLogger('SESSION')
@@ -239,6 +239,13 @@ export async function handleOpencodeSession({
     }
   }
 
+  // Cancel any pending question tool if user sends a new message
+  const questionCancelled = await cancelPendingQuestion(thread.id)
+  if (questionCancelled) {
+    sessionLogger.log(`[QUESTION] Cancelled pending question due to new message`)
+    await sendThreadMessage(thread, `⚠️ Previous question cancelled - processing your new message`)
+  }
+
   const abortController = new AbortController()
   abortControllers.set(session.id, abortController)
 
@@ -399,7 +406,8 @@ export async function handleOpencodeSession({
                 const thresholdCrossed = Math.floor(currentPercentage / 10) * 10
                 if (thresholdCrossed > lastDisplayedContextPercentage && thresholdCrossed >= 10) {
                   lastDisplayedContextPercentage = thresholdCrossed
-                  await sendThreadMessage(thread, `⬥ context usage ${currentPercentage}%`)
+                  const chunk = `⬦ context usage ${currentPercentage}%`
+                  await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
                 }
               }
             }
@@ -429,9 +437,40 @@ export async function handleOpencodeSession({
           }
 
           if (part.type === 'tool' && part.state.status === 'running') {
+            // Flush any pending text/reasoning parts before showing the tool
+            // This ensures text the LLM generated before the tool call is shown first
+            for (const p of currentParts) {
+              if (p.type !== 'step-start' && p.type !== 'step-finish' && p.id !== part.id) {
+                await sendPartMessage(p)
+              }
+            }
             await sendPartMessage(part)
           }
 
+          // Show token usage for completed tools with large output (>5k tokens)
+          if (part.type === 'tool' && part.state.status === 'completed') {
+            const output = part.state.output || ''
+            const outputTokens = Math.ceil(output.length / 4)
+            const LARGE_OUTPUT_THRESHOLD = 3000
+            if (outputTokens >= LARGE_OUTPUT_THRESHOLD) {
+              const formattedTokens = outputTokens >= 1000
+                ? `${(outputTokens / 1000).toFixed(1)}k`
+                : String(outputTokens)
+              const percentageSuffix = (() => {
+                if (!modelContextLimit) {
+                  return ''
+                }
+                const pct = (outputTokens / modelContextLimit) * 100
+                if (pct < 1) {
+                  return ''
+                }
+                return ` (${pct.toFixed(1)}%)`
+              })()
+              const chunk = `⬦ ${part.tool} returned ${formattedTokens} tokens${percentageSuffix}`
+              await thread.send({ content: chunk, flags: SILENT_MESSAGE_FLAGS })
+            }
+          }
+
           if (part.type === 'reasoning') {
             await sendPartMessage(part)
           }
@@ -530,6 +569,14 @@ export async function handleOpencodeSession({
             `Question requested: id=${questionRequest.id}, questions=${questionRequest.questions.length}`,
           )
 
+          // Flush any pending text/reasoning parts before showing the dropdown
+          // This ensures text the LLM generated before the question tool is shown first
+          for (const p of currentParts) {
+            if (p.type !== 'step-start' && p.type !== 'step-finish') {
+              await sendPartMessage(p)
+            }
+          }
+
           await showAskUserQuestionDropdowns({
             thread,
             sessionId: session.id,