kimaki 0.4.30 → 0.4.32

package/src/system-message.ts

@@ -38,17 +38,17 @@ IMPORTANT: After editing any files, you MUST execute the critique command using
 
 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,