kimaki 0.4.29 → 0.4.31

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 })
                 }
               }
             }
@@ -530,6 +538,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,
@@ -690,7 +706,7 @@ export async function handleOpencodeSession({
           path: { id: session.id },
           body: {
             parts,
-            system: getOpencodeSystemMessage({ sessionId: session.id }),
+            system: getOpencodeSystemMessage({ sessionId: session.id, channelId }),
             model: modelParam,
             agent: agentPreference,
           },

package/src/system-message.ts

@@ -2,13 +2,13 @@
 // Creates the system message injected into every OpenCode session,
 // including Discord-specific formatting rules, diff commands, and permissions info.
 
-export function getOpencodeSystemMessage({ sessionId }: { sessionId: string }) {
+export function getOpencodeSystemMessage({ sessionId, channelId }: { sessionId: string; channelId?: string }) {
   return `
 The user is reading your messages from inside Discord, via kimaki.xyz
 
 The user cannot see bash tool outputs. If there is important information in bash output, include it in your text response.
 
-Your current OpenCode session ID is: ${sessionId}
+Your current OpenCode session ID is: ${sessionId}${channelId ? `\nYour current Discord channel ID is: ${channelId}` : ''}
 
 ## permissions
 
@@ -23,24 +23,32 @@ Only users with these Discord permissions can send messages to the bot:
 To upload files to the Discord thread (images, screenshots, long files that would clutter the chat), run:
 
 npx -y kimaki upload-to-discord --session ${sessionId} <file1> [file2] ...
+${channelId ? `
+## starting new sessions from CLI
 
+To start a new thread/session in this channel programmatically, run:
+
+npx -y kimaki start-session --channel ${channelId} --prompt "your prompt here"
+
+This is useful for automation (cron jobs, GitHub webhooks, n8n, etc.)
+` : ''}
 ## showing diffs
 
 IMPORTANT: After editing any files, you MUST execute the critique command using the Bash tool to get a diff URL, then share that URL with the user.
 
 Execute this after making changes:
 
-bunx critique web
+bunx critique web --title "Add user authentication flow"
 
 If there are other unrelated changes in the working directory, filter to only show the files you edited:
 
-bunx critique web -- path/to/file1.ts path/to/file2.ts
+bunx critique web --title "Fix database connection retry" -- path/to/file1.ts path/to/file2.ts
 
 You can also show latest commit changes using:
 
-bunx critique web HEAD
+bunx critique web --title "Refactor API endpoints" HEAD
 
-bunx critique web HEAD~1 to get the one before last
+bunx critique web --title "Update dependencies" HEAD~1 to get the one before last
 
 Do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
 

package/src/unnest-code-blocks.test.ts

@@ -0,0 +1,225 @@
+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/src/unnest-code-blocks.ts

@@ -0,0 +1,127 @@
+// Unnest code blocks from list items for Discord.
+// Discord doesn't render code blocks inside lists, so this hoists them
+// to root level while preserving list structure.
+
+import { Lexer, type Token, type Tokens } from 'marked'
+
+type Segment =
+  | { type: 'list-item'; prefix: string; content: string }
+  | { type: 'code'; content: string }
+
+export function unnestCodeBlocksFromLists(markdown: string): string {
+  const lexer = new Lexer()
+  const tokens = lexer.lex(markdown)
+
+  const result: string[] = []
+  for (const token of tokens) {
+    if (token.type === 'list') {
+      const segments = processListToken(token as Tokens.List)
+      result.push(renderSegments(segments))
+    } else {
+      result.push(token.raw)
+    }
+  }
+  return result.join('')
+}
+
+function processListToken(list: Tokens.List): Segment[] {
+  const segments: Segment[] = []
+  const start = typeof list.start === 'number' ? list.start : parseInt(list.start, 10) || 1
+  const prefix = list.ordered ? (i: number) => `${start + i}. ` : () => '- '
+
+  for (let i = 0; i < list.items.length; i++) {
+    const item = list.items[i]!
+    const itemSegments = processListItem(item, prefix(i))
+    segments.push(...itemSegments)
+  }
+
+  return segments
+}
+
+function processListItem(item: Tokens.ListItem, prefix: string): Segment[] {
+  const segments: Segment[] = []
+  let currentText: string[] = []
+
+  const flushText = (): void => {
+    const text = currentText.join('').trim()
+    if (text) {
+      segments.push({ type: 'list-item', prefix, content: text })
+    }
+    currentText = []
+  }
+
+  for (const token of item.tokens) {
+    if (token.type === 'code') {
+      flushText()
+      const codeToken = token as Tokens.Code
+      const lang = codeToken.lang || ''
+      segments.push({
+        type: 'code',
+        content: '```' + lang + '\n' + codeToken.text + '\n```\n',
+      })
+    } else if (token.type === 'list') {
+      flushText()
+      // Recursively process nested list - segments bubble up
+      const nestedSegments = processListToken(token as Tokens.List)
+      segments.push(...nestedSegments)
+    } else {
+      currentText.push(extractText(token))
+    }
+  }
+
+  flushText()
+
+  // If no segments were created (empty item), return empty
+  if (segments.length === 0) {
+    return []
+  }
+
+  // If item had no code blocks (all segments are list-items from this level),
+  // return original raw to preserve formatting
+  const hasCode = segments.some((s) => s.type === 'code')
+  if (!hasCode) {
+    return [{ type: 'list-item', prefix: '', content: item.raw }]
+  }
+
+  return segments
+}
+
+function extractText(token: Token): string {
+  if (token.type === 'text') {
+    return (token as Tokens.Text).text
+  }
+  if (token.type === 'space') {
+    return ''
+  }
+  if ('raw' in token) {
+    return token.raw
+  }
+  return ''
+}
+
+function renderSegments(segments: Segment[]): string {
+  const result: string[] = []
+
+  for (let i = 0; i < segments.length; i++) {
+    const segment = segments[i]!
+    const prev = segments[i - 1]
+
+    if (segment.type === 'code') {
+      // Add newline before code if previous was a list item
+      if (prev && prev.type === 'list-item') {
+        result.push('\n')
+      }
+      result.push(segment.content)
+    } else {
+      // list-item
+      if (segment.prefix) {
+        result.push(segment.prefix + segment.content + '\n')
+      } else {
+        // Raw content (no prefix means it's original raw)
+        result.push(segment.content)
+      }
+    }
+  }
+
+  return result.join('')
+}

package/src/utils.ts

@@ -29,6 +29,7 @@ export function generateBotInstallUrl({
     PermissionsBitField.Flags.AttachFiles,
     PermissionsBitField.Flags.Connect,
     PermissionsBitField.Flags.Speak,
+    PermissionsBitField.Flags.ManageRoles,
   ],
   scopes = ['bot'],
   guildId,