@otto-assistant/bridge 0.4.92

package/src/kimaki-digital-twin.e2e.test.ts

@@ -0,0 +1,199 @@
+// End-to-end test using discord-digital-twin + real Kimaki bot runtime.
+// Verifies onboarding channel creation, message -> thread creation, and assistant reply.
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { expect, test } from 'vitest'
+import { ChannelType, Client, GatewayIntentBits, Partials } from 'discord.js'
+import { DigitalDiscord } from 'discord-digital-twin/src'
+import { CachedOpencodeProviderProxy } from 'opencode-cached-provider'
+import { setDataDir } from './config.js'
+import { startDiscordBot } from './discord-bot.js'
+import {
+  setBotToken,
+  initDatabase,
+  closeDatabase,
+  setChannelDirectory,
+} from './database.js'
+import { startHranaServer, stopHranaServer } from './hrana-server.js'
+import { cleanupTestSessions, chooseLockPort, initTestGitRepo } from './test-utils.js'
+import { stopOpencodeServer } from './opencode.js'
+
+const geminiApiKey =
+  process.env['GEMINI_API_KEY'] ||
+  process.env['GOOGLE_GENERATIVE_AI_API_KEY'] ||
+  ''
+const geminiModel = process.env['GEMINI_FLASH_MODEL'] || 'gemini-2.5-flash'
+const e2eTest = geminiApiKey.length > 0 ? test : test.skip
+
+function createRunDirectories() {
+  const root = path.resolve(process.cwd(), 'tmp', 'kimaki-digital-twin-e2e')
+  fs.mkdirSync(root, { recursive: true })
+
+  const dataDir = fs.mkdtempSync(path.join(root, 'data-'))
+  const projectDirectory = path.join(root, 'project')
+  const providerCacheDbPath = path.join(root, 'provider-cache.db')
+  fs.mkdirSync(projectDirectory, { recursive: true })
+  initTestGitRepo(projectDirectory)
+
+  return {
+    root,
+    dataDir,
+    projectDirectory,
+    providerCacheDbPath,
+  }
+}
+
+function createDiscordJsClient({ restUrl }: { restUrl: string }) {
+  return new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+      GatewayIntentBits.GuildVoiceStates,
+    ],
+    partials: [
+      Partials.Channel,
+      Partials.Message,
+      Partials.User,
+      Partials.ThreadMember,
+    ],
+    rest: {
+      api: restUrl,
+      version: '10',
+    },
+  })
+}
+
+e2eTest(
+  'onboarding then message creates thread and assistant reply via digital twin',
+  async () => {
+    const testStartTime = Date.now()
+    const directories = createRunDirectories()
+    const lockPort = chooseLockPort({ key: 'kimaki-digital-twin-e2e' })
+
+    process.env['KIMAKI_LOCK_PORT'] = String(lockPort)
+    setDataDir(directories.dataDir)
+
+    const proxy = new CachedOpencodeProviderProxy({
+      cacheDbPath: directories.providerCacheDbPath,
+      targetBaseUrl: 'https://generativelanguage.googleapis.com/v1beta',
+      apiKey: geminiApiKey,
+      cacheMethods: ['POST'],
+    })
+
+    const testUserId = '100000000000000777'
+    const textChannelId = '100000000000000778'
+    const digitalDiscordDbPath = path.join(
+      directories.dataDir,
+      'digital-discord.db',
+    )
+    const discord = new DigitalDiscord({
+      guild: {
+        name: 'Kimaki E2E Guild',
+        ownerId: testUserId,
+      },
+      channels: [
+        {
+          id: textChannelId,
+          name: 'kimaki-e2e',
+          type: ChannelType.GuildText,
+        },
+      ],
+      users: [
+        {
+          id: testUserId,
+          username: 'e2e-user',
+        },
+      ],
+      dbUrl: `file:${digitalDiscordDbPath}`,
+    })
+
+    let botClient: Client | null = null
+
+    try {
+      await Promise.all([proxy.start(), discord.start()])
+
+      const opencodeConfig = proxy.buildOpencodeConfig({
+        providerName: 'cached-google',
+        providerNpm: '@ai-sdk/google',
+        model: geminiModel,
+        smallModel: geminiModel,
+      })
+      fs.writeFileSync(
+        path.join(directories.projectDirectory, 'opencode.json'),
+        JSON.stringify(opencodeConfig, null, 2),
+      )
+
+      const dbPath = path.join(directories.dataDir, 'discord-sessions.db')
+      const hranaResult = await startHranaServer({ dbPath })
+      if (hranaResult instanceof Error) {
+        throw hranaResult
+      }
+      process.env['KIMAKI_DB_URL'] = hranaResult
+      await initDatabase()
+      await setBotToken(discord.botUserId, discord.botToken)
+
+      await setChannelDirectory({
+        channelId: textChannelId,
+        directory: directories.projectDirectory,
+        channelType: 'text',
+      })
+
+      botClient = createDiscordJsClient({ restUrl: discord.restUrl })
+      await startDiscordBot({
+        token: discord.botToken,
+        appId: discord.botUserId,
+        discordClient: botClient,
+      })
+
+      await discord.channel(textChannelId).user(testUserId).sendMessage({
+        content: 'Reply with exactly: kimaki digital twin ok',
+      })
+
+      const createdThread = await discord.channel(textChannelId).waitForThread({
+        timeout: 60_000,
+        predicate: (thread) => {
+          return thread.name === 'Reply with exactly: kimaki digital twin ok'
+        },
+      })
+
+      const botReply = await discord.thread(createdThread.id).waitForBotReply({
+        timeout: 120_000,
+      })
+
+      expect(createdThread.id.length).toBeGreaterThan(0)
+      expect(botReply.content.trim().length).toBeGreaterThan(0)
+    } finally {
+      await cleanupTestSessions({
+        projectDirectory: directories.projectDirectory,
+        testStartTime,
+      })
+
+      if (botClient) {
+        botClient.destroy()
+      }
+
+      await stopOpencodeServer()
+      await Promise.all([
+        closeDatabase().catch(() => {
+          return
+        }),
+        stopHranaServer().catch(() => {
+          return
+        }),
+        proxy.stop().catch(() => {
+          return
+        }),
+        discord.stop().catch(() => {
+          return
+        }),
+      ])
+
+      delete process.env['KIMAKI_LOCK_PORT']
+      delete process.env['KIMAKI_DB_URL']
+      fs.rmSync(directories.dataDir, { recursive: true, force: true })
+    }
+  },
+  360_000,
+)

package/src/kimaki-opencode-plugin-loading.e2e.test.ts

@@ -0,0 +1,109 @@
+// E2e test for OpenCode plugin loading.
+// Spawns `opencode serve` directly with our plugin in OPENCODE_CONFIG_CONTENT,
+// waits for the health endpoint, then checks stderr for plugin errors.
+// No Discord infrastructure needed — just the OpenCode server process.
+
+import { spawn, type ChildProcess } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { test, expect } from 'vitest'
+import { resolveOpencodeCommand } from './opencode.js'
+import { getSpawnCommandAndArgs } from './opencode-command.js'
+import { chooseLockPort } from './test-utils.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+async function waitForHealth({
+  port,
+  maxAttempts = 30,
+}: {
+  port: number
+  maxAttempts?: number
+}): Promise<boolean> {
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      const response = await fetch(`http://127.0.0.1:${port}/api/health`)
+      if (response.status < 500) {
+        return true
+      }
+    } catch {
+      // connection refused, retry
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 1000)
+    })
+  }
+  return false
+}
+
+test(
+  'opencode server loads plugin without errors',
+  async () => {
+    const projectDir = path.resolve(process.cwd(), 'tmp', 'plugin-loading-e2e')
+    fs.mkdirSync(projectDir, { recursive: true })
+
+    const port = chooseLockPort({ key: 'opencode-plugin-loading-e2e' })
+    const pluginPath = new URL('../src/kimaki-opencode-plugin.ts', import.meta.url).href
+    const stderrLines: string[] = []
+    const isolatedOpencodeRoot = path.join(projectDir, 'opencode-test-home')
+
+    const {
+      command,
+      args,
+      windowsVerbatimArguments,
+    } = getSpawnCommandAndArgs({
+      resolvedCommand: resolveOpencodeCommand(),
+      baseArgs: ['serve', '--port', port.toString(), '--print-logs', '--log-level', 'DEBUG'],
+    })
+
+    const serverProcess: ChildProcess = spawn(command, args, {
+      stdio: 'pipe',
+      cwd: projectDir,
+      windowsVerbatimArguments,
+      env: {
+        ...process.env,
+        OPENCODE_CONFIG_CONTENT: JSON.stringify({
+          $schema: 'https://opencode.ai/config.json',
+          lsp: false,
+          formatter: false,
+          plugin: [pluginPath],
+        }),
+        OPENCODE_TEST_HOME: isolatedOpencodeRoot,
+        OPENCODE_CONFIG_DIR: path.join(isolatedOpencodeRoot, '.opencode-kimaki'),
+        XDG_CONFIG_HOME: path.join(isolatedOpencodeRoot, '.config'),
+        XDG_DATA_HOME: path.join(isolatedOpencodeRoot, '.local', 'share'),
+        XDG_CACHE_HOME: path.join(isolatedOpencodeRoot, '.cache'),
+        XDG_STATE_HOME: path.join(isolatedOpencodeRoot, '.local', 'state'),
+      },
+    })
+
+    serverProcess.stderr?.on('data', (data) => {
+      stderrLines.push(...data.toString().split('\n').filter(Boolean))
+    })
+
+    try {
+      const healthy = await waitForHealth({ port })
+      expect(healthy).toBe(true)
+
+      // Check no plugin-related errors in stderr
+      const pluginErrorPatterns = [
+        /plugin.*error/i,
+        /failed to load plugin/i,
+        /cannot find module/i,
+        /ERR_MODULE_NOT_FOUND/i,
+        /plugin.*failed/i,
+        /plugin.*crash/i,
+      ]
+      const errorLines = stderrLines.filter((line) => {
+        return pluginErrorPatterns.some((pattern) => {
+          return pattern.test(line)
+        })
+      })
+      expect(errorLines).toEqual([])
+    } finally {
+      serverProcess.kill('SIGTERM')
+    }
+  },
+  60_000,
+)

package/src/kimaki-opencode-plugin.test.ts

@@ -0,0 +1,108 @@
+import { test, expect, describe } from 'vitest'
+import { condenseMemoryMd } from './condense-memory.js'
+
+describe('condenseMemoryMd', () => {
+  test('multiple headings with body content', () => {
+    const content = [
+      '# Project Overview',
+      '',
+      'This is a big project with many things.',
+      'It does X, Y, and Z.',
+      '',
+      '## Auth Architecture',
+      '',
+      'JWT tokens with 15min expiry.',
+      'Refresh tokens in httpOnly cookies.',
+      'Session stored in Redis.',
+      '',
+      '## User Preferences',
+      '',
+      '- kebab-case filenames',
+      '- errore-style errors',
+      '- no emojis',
+      '',
+      '### API Conventions',
+      '',
+      'All routes return { data, error }.',
+      'Use spiceflow for the server.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # Project Overview
+      ...
+      6: ## Auth Architecture
+      ...
+      12: ## User Preferences
+      ...
+      18: ### API Conventions
+      ..."
+    `)
+  })
+
+  test('body text before first heading', () => {
+    const content = [
+      'Some preamble notes.',
+      '',
+      '# First Heading',
+      '',
+      'Content here.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "...
+      3: # First Heading
+      ..."
+    `)
+  })
+
+  test('no headings at all', () => {
+    const content = 'Just some notes.\nMore notes.\n'
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`"..."`)
+  })
+
+  test('empty content', () => {
+    expect(condenseMemoryMd('')).toMatchInlineSnapshot(`""`)
+  })
+
+  test('consecutive headings without body', () => {
+    const content = [
+      '# H1',
+      '## H2',
+      '### H3',
+      '',
+      'Some body.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # H1
+      2: ## H2
+      3: ### H3
+      ..."
+    `)
+  })
+
+  test('heading with code block body', () => {
+    const content = [
+      '# Config',
+      '',
+      '```json',
+      '{ "key": "value" }',
+      '```',
+      '',
+      '## Notes',
+      '',
+      'Some text.',
+      '',
+    ].join('\n')
+
+    expect(condenseMemoryMd(content)).toMatchInlineSnapshot(`
+      "1: # Config
+      ...
+      7: ## Notes
+      ..."
+    `)
+  })
+})

package/src/kimaki-opencode-plugin.ts

@@ -0,0 +1,18 @@
+// OpenCode plugin entry point for Kimaki Discord bot.
+// Each export is treated as a separate plugin by OpenCode's plugin loader.
+// CRITICAL: never export utility functions from this file — only plugin
+// initializer functions. OpenCode calls every export as a plugin.
+//
+// Plugins are split into focused modules:
+// - ipc-tools-plugin: file upload + action buttons (IPC-based Discord tools)
+// - context-awareness-plugin: branch, pwd, memory, time gap, onboarding tutorial
+// - opencode-interrupt-plugin: interrupt queued messages at step boundaries
+// - kitty-graphics-plugin: extract Kitty Graphics Protocol images from bash output
+
+export { ipcToolsPlugin } from './ipc-tools-plugin.js'
+export { contextAwarenessPlugin } from './context-awareness-plugin.js'
+export { interruptOpencodeSessionOnUserMessage } from './opencode-interrupt-plugin.js'
+export { anthropicAuthPlugin } from './anthropic-auth-plugin.js'
+export { imageOptimizerPlugin } from './image-optimizer-plugin.js'
+export { kittyGraphicsPlugin } from 'kitty-graphics-agent'
+export { injectionGuardInternal as injectionGuard } from 'opencode-injection-guard'

package/src/limit-heading-depth.test.ts

@@ -0,0 +1,116 @@
+import { expect, test } from 'vitest'
+import { limitHeadingDepth } from './limit-heading-depth.js'
+
+test('converts h4 to h3', () => {
+  const input = '#### Fourth level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "### Fourth level heading
+    "
+  `)
+})
+
+test('converts h5 to h3', () => {
+  const input = '##### Fifth level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "### Fifth level heading
+    "
+  `)
+})
+
+test('converts h6 to h3', () => {
+  const input = '###### Sixth level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "### Sixth level heading
+    "
+  `)
+})
+
+test('preserves h3 unchanged', () => {
+  const input = '### Third level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`"### Third level heading"`)
+})
+
+test('preserves h2 unchanged', () => {
+  const input = '## Second level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`"## Second level heading"`)
+})
+
+test('preserves h1 unchanged', () => {
+  const input = '# First level heading'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`"# First level heading"`)
+})
+
+test('handles multiple headings in document', () => {
+  const input = `# Title
+
+Some text
+
+## Section
+
+### Subsection
+
+#### Too deep
+
+##### Even deeper
+
+Regular paragraph
+
+### Back to normal
+`
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "# Title
+
+    Some text
+
+    ## Section
+
+    ### Subsection
+
+    ### Too deep
+    ### Even deeper
+    Regular paragraph
+
+    ### Back to normal
+    "
+  `)
+})
+
+test('preserves heading with inline formatting', () => {
+  const input = '#### Heading with **bold** and `code`'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "### Heading with **bold** and \`code\`
+    "
+  `)
+})
+
+test('handles empty markdown', () => {
+  const result = limitHeadingDepth('')
+  expect(result).toMatchInlineSnapshot(`""`)
+})
+
+test('handles markdown with no headings', () => {
+  const input = 'Just some text\n\nAnd more text'
+  const result = limitHeadingDepth(input)
+  expect(result).toMatchInlineSnapshot(`
+    "Just some text
+
+    And more text"
+  `)
+})
+
+test('allows custom maxDepth', () => {
+  const input = '### Third level'
+  const result = limitHeadingDepth(input, 2)
+  expect(result).toMatchInlineSnapshot(`
+    "## Third level
+    "
+  `)
+})

package/src/limit-heading-depth.ts

@@ -0,0 +1,26 @@
+// Limit heading depth for Discord.
+// Discord only supports headings up to ### (h3), so this converts
+// ####, #####, etc. to ### to maintain consistent rendering.
+
+import { Lexer, type Tokens } from 'marked'
+
+export function limitHeadingDepth(markdown: string, maxDepth = 3): string {
+  const lexer = new Lexer()
+  const tokens = lexer.lex(markdown)
+
+  let result = ''
+  for (const token of tokens) {
+    if (token.type === 'heading') {
+      const heading = token as Tokens.Heading
+      if (heading.depth > maxDepth) {
+        const hashes = '#'.repeat(maxDepth)
+        result += hashes + ' ' + heading.text + '\n'
+      } else {
+        result += token.raw
+      }
+    } else {
+      result += token.raw
+    }
+  }
+  return result
+}